@astrosheep/keiyaku 4.6.11 → 4.6.13

package/build/src/akuma/providers/opencode-sdk/events.js

@@ -4,37 +4,53 @@ export function diagnostic(value) {
     const data = object(value);
     return text(data?.message) ?? text(object(data?.data)?.message) ?? "OpenCode execution failed";
 }
+function shellCall(value) {
+    return { kind: "run", command: text(value?.command) ?? "shell" };
+}
+function readCall(value) {
+    const path = text(value?.filePath) ?? text(value?.path);
+    if (path === undefined)
+        return undefined;
+    return {
+        kind: "read",
+        path,
+        ...(positiveLine(value?.offset) === undefined ? {} : { offset: positiveLine(value?.offset) }),
+        ...(positiveLine(value?.limit) === undefined ? {} : { limit: positiveLine(value?.limit) }),
+    };
+}
+function searchCall(name, value) {
+    const query = text(value?.pattern);
+    const path = text(value?.path);
+    if (query === undefined)
+        return undefined;
+    return {
+        kind: "search",
+        scope: name === "glob" ? "files" : "content",
+        query,
+        ...(path === undefined ? {} : { path }),
+    };
+}
+function editCall(value) {
+    const path = text(value?.path);
+    if (path !== undefined)
+        return { kind: "fileChange", changes: [{ op: "update", path }] };
+    return undefined;
+}
 function callFor(name, input) {
     const value = object(input);
-    if (name === "shell")
-        return { kind: "run", command: text(value?.command) ?? name };
-    if (name === "read") {
-        const path = text(value?.filePath) ?? text(value?.path);
-        if (path !== undefined)
-            return {
-                kind: "read",
-                path,
-                ...(positiveLine(value?.offset) === undefined ? {} : { offset: positiveLine(value?.offset) }),
-                ...(positiveLine(value?.limit) === undefined ? {} : { limit: positiveLine(value?.limit) }),
-            };
-    }
-    if (name === "grep" || name === "glob") {
-        const query = text(value?.pattern);
-        const path = text(value?.path);
-        if (query !== undefined)
-            return {
-                kind: "search",
-                scope: name === "glob" ? "files" : "content",
-                query,
-                ...(path === undefined ? {} : { path }),
-            };
-    }
-    if (name === "edit") {
-        const path = text(value?.path);
-        if (path !== undefined)
-            return { kind: "fileChange", changes: [{ op: "update", path }] };
+    switch (name) {
+        case "shell":
+            return shellCall(value);
+        case "read":
+            return readCall(value) ?? otherToolCall(name, input);
+        case "grep":
+        case "glob":
+            return searchCall(name, value) ?? otherToolCall(name, input);
+        case "edit":
+            return editCall(value) ?? otherToolCall(name, input);
+        default:
+            return otherToolCall(name, input);
     }
-    return otherToolCall(name, input);
 }
 function observedChanges(metadata) {
     const files = object(metadata)?.files;
@@ -101,6 +117,46 @@ const DROPPED = new Set([
     "session.tool.progress",
     "session.retry.scheduled",
 ]);
+function toolResult(type, data) {
+    const observed = output(data.content);
+    const nativeExit = object(data.metadata)?.exit;
+    const exit = typeof nativeExit === "number" && Number.isInteger(nativeExit) ? nativeExit : undefined;
+    return {
+        status: type === "session.tool.failed" || (exit !== undefined && exit !== 0) ? "error" : "ok",
+        ...(type === "session.tool.failed" ? { message: diagnostic(data.error) } : {}),
+        ...(observed === undefined ? {} : { output: observed }),
+        ...(exit === undefined ? {} : { exitCode: exit }),
+    };
+}
+function toolEvent(type, data, events, state) {
+    const id = text(data.id);
+    const started = id === undefined ? undefined : state.tools.get(id);
+    if (id === undefined || started === undefined || state.completed.has(id))
+        return;
+    if (started.call === undefined) {
+        started.call = callFor(started.name, data.input);
+        events.emit({ type: "tool", phase: "started", id, name: started.name, call: started.call });
+    }
+    if (type === "session.tool.called")
+        return;
+    if (started.name === "edit" || started.name === "patch" || started.name === "write") {
+        started.call = observedChanges(data.metadata) ?? started.call;
+    }
+    const result = toolResult(type, data);
+    state.completed.add(id);
+    events.emit({ type: "tool", phase: "completed", id, name: started.name, call: started.call, result });
+}
+function stepStarted(data, events) {
+    const model = object(data.model);
+    const provider = text(model?.providerID);
+    const id = text(model?.id);
+    if (provider !== undefined && id !== undefined)
+        events.emit(modelEvent(`${provider}/${id}`));
+}
+function toolInputStarted(data, state) {
+    if (typeof data.id === "string" && typeof data.name === "string")
+        state.tools.set(data.id, { name: data.name });
+}
 /** Only complete native values enter narration. The caller enforces submission/step correlation. */
 export function mapEvent(value, events, state) {
     const event = object(value);
@@ -110,62 +166,36 @@ export function mapEvent(value, events, state) {
     if (state.sessionId !== undefined && data.sessionID !== state.sessionId)
         return;
     const type = event.type;
-    if (type === "session.step.started") {
-        const model = object(data.model);
-        const provider = text(model?.providerID);
-        const id = text(model?.id);
-        if (provider !== undefined && id !== undefined)
-            events.emit(modelEvent(`${provider}/${id}`));
-        return;
-    }
-    if (type === "session.text.ended" || type === "session.reasoning.ended") {
-        if (typeof data.text === "string")
-            events.emit({ type: type === "session.text.ended" ? "assistant" : "thought", text: data.text });
-        return;
-    }
-    if (type === "session.tool.input.started") {
-        if (typeof data.id === "string" && typeof data.name === "string")
-            state.tools.set(data.id, { name: data.name });
-        return;
-    }
-    if (type === "session.tool.called" || type === "session.tool.success" || type === "session.tool.failed") {
-        const id = text(data.id);
-        const started = id === undefined ? undefined : state.tools.get(id);
-        if (id === undefined || started === undefined || state.completed.has(id))
+    switch (type) {
+        case "session.step.started":
+            stepStarted(data, events);
             return;
-        if (started.call === undefined) {
-            started.call = callFor(started.name, data.input);
-            events.emit({ type: "tool", phase: "started", id, name: started.name, call: started.call });
-        }
-        if (type === "session.tool.called")
+        case "session.text.ended":
+        case "session.reasoning.ended":
+            if (typeof data.text === "string")
+                events.emit({ type: type === "session.text.ended" ? "assistant" : "thought", text: data.text });
             return;
-        if (started.name === "edit" || started.name === "patch" || started.name === "write") {
-            started.call = observedChanges(data.metadata) ?? started.call;
-        }
-        const observed = output(data.content);
-        const nativeExit = object(data.metadata)?.exit;
-        const exit = typeof nativeExit === "number" && Number.isInteger(nativeExit) ? nativeExit : undefined;
-        const result = {
-            status: type === "session.tool.failed" || (exit !== undefined && exit !== 0) ? "error" : "ok",
-            ...(type === "session.tool.failed" ? { message: diagnostic(data.error) } : {}),
-            ...(observed === undefined ? {} : { output: observed }),
-            ...(exit === undefined ? {} : { exitCode: exit }),
-        };
-        state.completed.add(id);
-        events.emit({ type: "tool", phase: "completed", id, name: started.name, call: started.call, result });
-        return;
-    }
-    if (type === "session.compaction.ended") {
-        events.emit(noteEvent("Context compacted"));
-        return;
-    }
-    if (type === "session.compaction.failed") {
-        events.emit(noteEvent(diagnostic(data.error)));
-        return;
+        case "session.tool.input.started":
+            toolInputStarted(data, state);
+            return;
+        case "session.tool.called":
+        case "session.tool.success":
+        case "session.tool.failed":
+            toolEvent(type, data, events, state);
+            return;
+        case "session.compaction.ended":
+            events.emit(noteEvent("Context compacted"));
+            return;
+        case "session.compaction.failed":
+            events.emit(noteEvent(diagnostic(data.error)));
+            return;
+        case "session.compaction.started":
+        case "session.compaction.delta":
+            return;
+        default:
+            if (!DROPPED.has(type))
+                events.emit({ type: "unknown", kind: type });
     }
-    if (type === "session.compaction.started" || type === "session.compaction.delta" || DROPPED.has(type))
-        return;
-    events.emit({ type: "unknown", kind: type });
 }
 export function createEventState(sessionId) {
     return { ...(sessionId === undefined ? {} : { sessionId }), tools: new Map(), completed: new Set() };

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -34,8 +34,16 @@ function ownRuntime(custody, runtime) {
         }
         return closing;
     };
-    custody.own({ closed, abort: close, forceDispose: close });
-    return close;
+    let abort = close;
+    let forceDispose = close;
+    custody.own({ closed, abort: () => abort(), forceDispose: () => forceDispose() });
+    return {
+        close,
+        setControls(controls) {
+            abort = controls.abort;
+            forceDispose = controls.forceDispose;
+        },
+    };
 }
 function liveAdmission(initial) {
     let latest = initial;
@@ -88,10 +96,52 @@ async function answer(runtime, id, assistantID, terminalID) {
     }
     return { kind: "answered", answer: text, historyId: boundary };
 }
+function executionResult(input, state, event, data) {
+    const type = event?.type;
+    if (type === "session.step.failed" || type === "session.execution.failed") {
+        return { kind: "failed", diagnostic: diagnostic(data.error) };
+    }
+    if (type === "session.execution.interrupted")
+        return { kind: "failed", diagnostic: "OpenCode native execution interrupted" };
+    if (type !== "session.execution.succeeded" || state.delivered === undefined)
+        return;
+    const step = state.step;
+    if (step === undefined || !step.ended || step.input !== input.admission.latest()) {
+        return { kind: "failed", diagnostic: "OpenCode completed without an assistant for the admitted input" };
+    }
+    const terminalID = nonblank(event?.id);
+    if (terminalID === undefined || !terminalID.startsWith("evt_"))
+        return { kind: "failed", diagnostic: "OpenCode terminal identity missing" };
+    return answer(input.runtime, input.id, step.id, terminalID);
+}
+function observeEvent(input, state, event, data) {
+    const type = event?.type;
+    if (type === "session.inbox.enqueued" && typeof data.inboxID === "string" && object(data.item)?.type === "user") {
+        input.admission.admit(data.inboxID);
+    }
+    if (type === "session.inbox.delivered" && typeof data.inboxID === "string") {
+        if (!input.admission.owns(data.inboxID)) {
+            return {
+                kind: "failed",
+                diagnostic: "OpenCode consumed another writer's input; exact answer attribution unavailable",
+            };
+        }
+        input.admission.admit(data.inboxID);
+        state.delivered = data.inboxID;
+    }
+    if (type === "session.step.started" && state.delivered !== undefined && typeof data.assistantMessageID === "string") {
+        state.step = { id: data.assistantMessageID, input: state.delivered, ended: false };
+    }
+    if (data.assistantMessageID !== undefined && data.assistantMessageID !== state.step?.id)
+        return;
+    if (state.delivered !== undefined)
+        mapEvent(event, input.events, state.narration);
+    if (type === "session.step.ended" && state.step !== undefined)
+        state.step.ended = true;
+    return executionResult(input, state, event, data);
+}
 async function observe(input) {
-    const state = createEventState(input.id);
-    let delivered;
-    let step;
+    const state = { narration: createEventState(input.id), delivered: undefined, step: undefined };
     try {
         for (;;) {
             const next = await input.stream.next();
@@ -101,43 +151,9 @@ async function observe(input) {
             const data = object(event?.data);
             if (data?.sessionID !== input.id)
                 continue;
-            const type = event?.type;
-            if (type === "session.inbox.enqueued" && typeof data.inboxID === "string" && object(data.item)?.type === "user") {
-                input.admission.admit(data.inboxID);
-            }
-            if (type === "session.inbox.delivered" && typeof data.inboxID === "string") {
-                if (!input.admission.owns(data.inboxID)) {
-                    return {
-                        kind: "failed",
-                        diagnostic: "OpenCode consumed another writer's input; exact answer attribution unavailable",
-                    };
-                }
-                input.admission.admit(data.inboxID);
-                delivered = data.inboxID;
-            }
-            if (type === "session.step.started" && delivered !== undefined && typeof data.assistantMessageID === "string") {
-                step = { id: data.assistantMessageID, input: delivered, ended: false };
-            }
-            if (data.assistantMessageID !== undefined && data.assistantMessageID !== step?.id)
-                continue;
-            if (delivered !== undefined)
-                mapEvent(event, input.events, state);
-            if (type === "session.step.ended" && step !== undefined)
-                step.ended = true;
-            if (type === "session.step.failed" || type === "session.execution.failed") {
-                return { kind: "failed", diagnostic: diagnostic(data.error) };
-            }
-            if (type === "session.execution.interrupted")
-                return { kind: "failed", diagnostic: "OpenCode native execution interrupted" };
-            if (type !== "session.execution.succeeded" || delivered === undefined)
-                continue;
-            if (step === undefined || !step.ended || step.input !== input.admission.latest()) {
-                return { kind: "failed", diagnostic: "OpenCode completed without an assistant for the admitted input" };
-            }
-            const terminalID = nonblank(event?.id);
-            if (terminalID === undefined || !terminalID.startsWith("evt_"))
-                return { kind: "failed", diagnostic: "OpenCode terminal identity missing" };
-            return await answer(input.runtime, input.id, step.id, terminalID);
+            const result = observeEvent(input, state, event, data);
+            if (result !== undefined)
+                return await result;
         }
     }
     catch (error) {
@@ -147,6 +163,25 @@ async function observe(input) {
         input.admission.end();
     }
 }
+async function configureSession(runtime, input, id, info, model) {
+    const session = runtime.client.session;
+    let selected = object(info?.model);
+    if (input.session.kind === "resume" && model !== undefined) {
+        await session.switchModel({ id, model });
+        selected = object(object(object(await session.get({ id }))?.data)?.model);
+    }
+    if (model !== undefined &&
+        (selected?.providerID !== model.providerID ||
+            selected.id !== model.id ||
+            (selected.variant ?? "default") !== (input.options.effort ?? "default"))) {
+        throw new Error("OpenCode did not select the requested model");
+    }
+    if (input.options.systemPrompt !== undefined) {
+        // Native instruction entries join the system transcript and survive resume
+        // and fork. Updating the same entry announces an upstream instruction change.
+        await session.instructions({ id, text: input.options.systemPrompt });
+    }
+}
 async function openSession(runtime, input) {
     const model = input.options.model === undefined
         ? undefined
@@ -169,38 +204,18 @@ async function openSession(runtime, input) {
         throw new Error("OpenCode active execution response missing");
     if (active[id] !== undefined)
         throw new Error("OpenCode native session is already busy");
-    let selected = object(info?.model);
-    if (input.session.kind === "resume" && model !== undefined) {
-        await session.switchModel({ id, model });
-        selected = object(object(object(await session.get({ id }))?.data)?.model);
-    }
-    if (model !== undefined &&
-        (selected?.providerID !== model.providerID ||
-            selected.id !== model.id ||
-            (selected.variant ?? "default") !== (input.options.effort ?? "default"))) {
-        throw new Error("OpenCode did not select the requested model");
-    }
-    if (input.options.systemPrompt !== undefined) {
-        // Native instruction entries join the system transcript and survive resume
-        // and fork. Updating the same entry announces an upstream instruction change.
-        await session.instructions({ id, text: input.options.systemPrompt });
-    }
+    await configureSession(runtime, input, id, info, model);
     return id;
 }
-async function drive(execution, input, loader, custody) {
-    admit(input.options);
-    if (input.schemaJson !== undefined)
-        throw new Error("OpenCode v2 does not expose native structured answer schemas");
-    if (input.session.kind === "resume")
-        sessionId(input.session.coordinate);
-    let closeRuntime;
+async function openResources(execution, input, loader, custody) {
+    let runtimeOwner;
     const runtime = await loadOpencode({
         execution,
         cwd: input.cwd,
         signal: custody.signal,
         ...(loader === undefined ? {} : { loader }),
         onRuntime: (ready) => {
-            closeRuntime = ownRuntime(custody, ready);
+            runtimeOwner = ownRuntime(custody, ready);
         },
         ...(input.requests === undefined ? {} : { requests: input.requests.dir }),
     });
@@ -211,91 +226,105 @@ async function drive(execution, input, loader, custody) {
         subscribe: runtime.client.event.subscribe,
     });
     let closing;
-    const close = () => (closing ??= Promise.all([stream.retire(), closeRuntime()]).then(() => undefined));
-    try {
-        const id = await openSession(runtime, input);
-        await stream.ready;
-        custody.signal.throwIfAborted();
-        const events = new AgentEventChannel();
-        events.emit({ type: "session", coordinate: coordinate(id) });
-        let sequence = 0;
-        const initial = messageId(sequence++);
-        const admission = liveAdmission(initial);
-        let control;
-        let finishing = false;
-        let finish;
-        const completion = new Promise((resolve) => {
-            let settlement;
-            finish = (result) => {
-                finishing = true;
-                return (settlement ??= (async () => {
-                    await close();
-                    events.end();
-                    resolve(result);
-                })());
-            };
-        });
-        const observed = observe({ runtime, stream, id, admission, events });
-        // Start observation before submission: admission broadcasts can precede HTTP completion.
-        void observed
-            .then(async (result) => {
-            // Explicit interrupt owns its response too: a terminal broadcast can be
-            // published before that response, and must not close its connection early.
-            if (control !== undefined)
-                await control;
-            await finish(result);
-        })
-            .catch(() => undefined);
-        const prompt = async (nativeID, text) => {
-            const response = object(object(await runtime.client.session.prompt({ id, body: { id: nativeID, text } }))?.data);
-            if (response?.id !== nativeID || response.sessionID !== id || response.type !== "user") {
-                throw new Error("OpenCode returned no exact native inbox admission");
-            }
+    const close = () => (closing ??= Promise.all([stream.retire(), runtimeOwner.close()]).then(() => undefined));
+    return { runtime, stream, runtimeOwner, close };
+}
+async function submitPrompt(runtime, id, nativeID, text) {
+    const response = object(object(await runtime.client.session.prompt({ id, body: { id: nativeID, text } }))?.data);
+    if (response?.id !== nativeID || response.sessionID !== id || response.type !== "user") {
+        throw new Error("OpenCode returned no exact native inbox admission");
+    }
+}
+async function openTurn(input, signal, resources, id) {
+    const { runtime, stream, runtimeOwner, close } = resources;
+    const events = new AgentEventChannel();
+    events.emit({ type: "session", coordinate: coordinate(id) });
+    const initial = messageId();
+    const admission = liveAdmission(initial);
+    let control;
+    let finishing = false;
+    let finish;
+    const completion = new Promise((resolve) => {
+        let settlement;
+        finish = (result) => {
+            finishing = true;
+            return (settlement ??= (async () => {
+                await close();
+                events.end();
+                resolve(result);
+            })());
         };
-        await prompt(initial, launchPrompt(input.body, input.launchTells));
+    });
+    const observed = observe({ runtime, stream, id, admission, events });
+    // Start observation before submission: admission broadcasts can precede HTTP completion.
+    void observed
+        .then(async (result) => {
+        // Explicit interrupt owns its response too: a terminal broadcast can be
+        // published before that response, and must not close its connection early.
+        if (control !== undefined)
+            await control;
+        await finish(result);
+    })
+        .catch(() => undefined);
+    const prompt = (nativeID, text) => submitPrompt(runtime, id, nativeID, text);
+    await prompt(initial, launchPrompt(input.body, input.launchTells));
+    signal.throwIfAborted();
+    let submissions = admission.initial.then(() => undefined);
+    const abort = async () => {
+        admission.end();
+        if (finishing) {
+            await close();
+            return;
+        }
+        // The v2 interrupt response follows execution settlement. Do not hide its
+        // refusal; server and connection retirement must still run on failure.
+        control ??= runtime.client.session.interrupt({ id });
+        try {
+            await control;
+        }
+        finally {
+            await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
+        }
+    };
+    const forceDispose = async () => {
+        admission.end();
+        await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
+    };
+    runtimeOwner.setControls({ abort, forceDispose });
+    return {
+        admission: { fence: initial },
+        events,
+        completion,
+        tell(tell) {
+            const submit = async () => {
+                if (!admission.open())
+                    return { kind: "turn-ended" };
+                const nativeID = messageId();
+                const receipt = admission.wait(nativeID);
+                void prompt(nativeID, tell.text).catch((error) => admission.fail(nativeID, error));
+                return await receipt;
+            };
+            const next = submissions.then(submit);
+            submissions = next.then(() => undefined, () => undefined);
+            return next;
+        },
+    };
+}
+async function drive(execution, input, loader, custody) {
+    admit(input.options);
+    if (input.schemaJson !== undefined)
+        throw new Error("OpenCode v2 does not expose native structured answer schemas");
+    if (input.session.kind === "resume")
+        sessionId(input.session.coordinate);
+    const resources = await openResources(execution, input, loader, custody);
+    try {
+        const id = await openSession(resources.runtime, input);
+        await resources.stream.ready;
         custody.signal.throwIfAborted();
-        let submissions = admission.initial.then(() => undefined);
-        return {
-            admission: { fence: initial },
-            events,
-            completion,
-            tell(tell) {
-                const submit = async () => {
-                    if (!admission.open())
-                        return { kind: "turn-ended" };
-                    const nativeID = messageId(sequence++);
-                    const receipt = admission.wait(nativeID);
-                    void prompt(nativeID, tell.text).catch((error) => admission.fail(nativeID, error));
-                    return await receipt;
-                };
-                const next = submissions.then(submit);
-                submissions = next.then(() => undefined, () => undefined);
-                return next;
-            },
-            abort: async () => {
-                admission.end();
-                if (finishing) {
-                    await close();
-                    return;
-                }
-                // The v2 interrupt response follows execution settlement. Do not hide its
-                // refusal; server and connection retirement must still run on failure.
-                control ??= runtime.client.session.interrupt({ id });
-                try {
-                    await control;
-                }
-                finally {
-                    await finish({ kind: "failed", diagnostic: "OpenCode session interrupted" });
-                }
-            },
-            forceDispose: async () => {
-                admission.end();
-                await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
-            },
-        };
+        return await openTurn(input, custody.signal, resources, id);
     }
     catch (error) {
-        await close();
+        await resources.close();
         throw error;
     }
 }
@@ -315,14 +344,14 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
         ...providerLifecycle((input, custody) => drive(execution, input, loader, custody)),
         fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => {
             const id = sessionId(input.session);
-            let close;
+            let runtimeOwner;
             const runtime = await loadOpencode({
                 execution,
                 cwd: input.cwd,
                 signal: custody.signal,
                 ...(loader === undefined ? {} : { loader }),
                 onRuntime: (ready) => {
-                    close = ownRuntime(custody, ready);
+                    runtimeOwner = ownRuntime(custody, ready);
                 },
             });
             try {
@@ -345,7 +374,7 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                 return { session: coordinate(child) };
             }
             finally {
-                await close();
+                await runtimeOwner.close();
             }
         }),
     };

package/build/src/akuma/providers/opencode-sdk/native-http.js

@@ -1,11 +1,15 @@
 import { OpenCode } from "@opencode/client";
-import { Agent } from "undici";
+import { Agent, fetch as undiciFetch } from "undici";
 import { object } from "../decode.js";
+// A dispatcher is only understood by the fetch built for the same Undici, and
+// Node's global fetch carries its own copy. Take both halves from the declared
+// dependency so the generated SDK cannot hand this Agent to a foreign Undici.
+const matchedFetch = undiciFetch;
 /** The matching native SDK owns the dialect; this attempt owns its HTTP connections. */
 export function createNativeClient(baseUrl, password) {
     const dispatcher = new Agent();
     const controller = new AbortController();
-    // Node's fetch accepts an Undici dispatcher in addition to standard RequestInit.
+    // Undici's fetch accepts a dispatcher in addition to standard RequestInit.
     // Keep that native extension at this one SDK seam.
     const ownedFetch = (input, init) => {
         controller.signal.throwIfAborted();
@@ -14,7 +18,7 @@ export function createNativeClient(baseUrl, password) {
             dispatcher,
             signal: init?.signal == null ? controller.signal : AbortSignal.any([controller.signal, init.signal]),
         };
-        return globalThis.fetch(input, options);
+        return matchedFetch(input, options);
     };
     const sdk = OpenCode.make({
         baseUrl,