Something went wrong. Try again.
opencode v2 mirror
Something went wrong. Try again.
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171export * as ToolInputRepairPlugin from "./tool-input-repair.js"
import { define } from "@opencode/plugin/effect/plugin"import { Effect, JsonSchema, Option, Predicate, Schema } from "effect"import { definition } from "../tool/runtime.js"
// Repairs apply only when the input schema unambiguously supports them:// - Stringified root or nested object: '{"limit":"20"}' -> { limit: 20 }// - Closed object: { limit: "20", extra: true } -> { limit: 20 }// - Optional null or empty-object placeholder: { limit: null } -> {}// - Numeric or boolean string: { limit: "20", enabled: "false" } -> { limit: 20, enabled: false }// - Nullable field: { count: "2" } -> { count: 2 }// - Stringified array or compatible item: { tags: '["a"]', count: "2" } -> { tags: ["a"], count: [2] }// - Positional tuple: { pair: ["2", "false"] } -> { pair: [2, false] }// - Typed dictionary: { counts: { first: "2" } } -> { counts: { first: 2 } }// - Nested fields and local references: { items: [{ count: "2" }] } -> { items: [{ count: 2 }] }
const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))const maxDepth = 6
export const Plugin = define({ id: "opencode.tool.input.repair", effect: (ctx) => ctx.tool.hook("execute.before", (event) => Effect.gen(function* () { // The outer Code Mode tool is built per snapshot rather than registered, so it cannot be // looked up here. Its `{ code }` input is trivial; the tools it calls are repaired normally. if (event.tool === "execute") return const tool = (yield* ctx.tool.list()).find((tool) => tool.id === event.tool) if (!tool) return const schema = definition(tool).inputSchema if (schema.type !== "object") return event.input = repair(event.input, schema, schema, 0) }), ),})
function repair(value: unknown, schema: JsonSchema.JsonSchema, root: JsonSchema.JsonSchema, depth: number): unknown { if (depth > maxDepth) return value
if (typeof schema.$ref === "string") { const definitions = /^#\/\$defs\/[^/]+$/.test(schema.$ref) ? root.$defs : /^#\/definitions\/[^/]+$/.test(schema.$ref) ? root.definitions : undefined if (!Predicate.isObject(definitions)) return value const target = Object.fromEntries( Object.entries(definitions).filter((entry): entry is [string, JsonSchema.JsonSchema] => Predicate.isObject(entry[1]), ), )[ schema.$ref .slice(schema.$ref.lastIndexOf("/") + 1) .replaceAll("~1", "/") .replaceAll("~0", "~") ] return target ? repair(value, target, root, depth + 1) : value }
if (Array.isArray(schema.type)) { if (value === null && schema.type.includes("null")) return value if (schema.type.includes(typeof value)) return value const types = schema.type.filter((type) => type !== "null") return types.length === 1 ? repair(value, { ...schema, type: types[0] }, root, depth + 1) : value }
if (schema.type === undefined) { if (Array.isArray(schema.anyOf) && Array.isArray(schema.oneOf)) return value const branches = Array.isArray(schema.anyOf) ? schema.anyOf : schema.oneOf if (!Array.isArray(branches) || value === null) return value if (branches.some((branch) => !Predicate.isObject(branch) || branch.type === typeof value)) return value const candidates = branches.filter((branch) => Predicate.isObject(branch) && branch.type !== "null") return candidates.length === 1 ? repair(value, candidates[0], root, depth + 1) : value }
if (schema.type === "number" || schema.type === "integer") { if (typeof value !== "string" || value.trim() === "") return value const parsed = Number(value) return Number.isFinite(parsed) && (schema.type !== "integer" || Number.isSafeInteger(parsed)) ? parsed : value } if (schema.type === "boolean") return value === "true" ? true : value === "false" ? false : value if (schema.type === "object") return repairObject(value, schema, root, depth) if (schema.type === "array") return repairArray(value, schema, root, depth) return value}
function repairObject( value: unknown, schema: JsonSchema.JsonSchema, root: JsonSchema.JsonSchema, depth: number,): unknown { const parsed = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value if (!Predicate.isObject(parsed)) return value
const properties = Predicate.isObject(schema.properties) ? schema.properties : {} const required = Array.isArray(schema.required) ? schema.required : [] const patterned = Predicate.isObject(schema.patternProperties) const composed = Array.isArray(schema.allOf) || Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)
return Object.keys(parsed).reduce<Record<string, unknown>>((result, key) => { const current = result[key] const declared = Object.hasOwn(properties, key) const property = declared ? properties[key] : !patterned ? schema.additionalProperties : undefined
if (!declared && schema.additionalProperties === false && !patterned && !composed) { const next = { ...result } delete next[key] return next } if (!Predicate.isObject(property)) return result
// Only a bare single-type property provably rejects null and `{}`. Compositions, enums, // constants, references and nullable flags may accept them, so those are left alone. const plain = typeof property.type === "string" && property.type !== "null" && !composed && ["anyOf", "oneOf", "allOf", "enum", "const", "$ref", "nullable"].every((keyword) => !(keyword in property)) const placeholder = Predicate.isObject(current) && Object.keys(current).length === 0 && property.type !== "object" if (declared && !required.includes(key) && plain && (current === null || placeholder)) { const next = { ...result } delete next[key] return next }
const repaired = repair(current, property, root, depth + 1) return repaired === current ? result : { ...result, [key]: repaired } }, parsed)}
function repairArray( value: unknown, schema: JsonSchema.JsonSchema, root: JsonSchema.JsonSchema, depth: number,): unknown { const parsed = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value const tuple = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.items) ? schema.items : undefined
if (Array.isArray(parsed)) { const repaired = parsed.map((item, index) => { const member = tuple ? (tuple[index] ?? (Array.isArray(schema.prefixItems) ? schema.items : schema.additionalItems)) : schema.items return Predicate.isObject(member) ? repair(item, member, root, depth + 1) : item }) return repaired.every((item, index) => item === parsed[index]) ? parsed : repaired }
if (tuple || !Predicate.isObject(schema.items)) return value const repaired = repair(value, schema.items, root, depth + 1) const type = schema.items.type const compatible = type === "object" ? Predicate.isObject(repaired) : type === "array" ? Array.isArray(repaired) : type === "integer" ? typeof repaired === "number" && Number.isSafeInteger(repaired) : type === "number" ? typeof repaired === "number" && Number.isFinite(repaired) : (type === "string" || type === "boolean") && typeof repaired === type return compatible ? [repaired] : value}