@astrosheep/keiyaku 0.1.86 → 1.0.0

package/build/agents/harness/pump.js

@@ -0,0 +1,152 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, readAdmissionLock, isTellCausallyConsumed, touchHeartbeat as touchHeartbeatFile, } from "../../core/projection-core.js";
+/** Tier-2 boundary snapshot. No tells leaves prompt byte-identical. */
+export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId) {
+    const tellIds = claimFencedTells(projectionDirectory, tellFence, executionId);
+    if (tellIds.length === 0)
+        return { prompt, tellIds };
+    const originals = tellIds.map((tellId) => readTellOriginal(projectionDirectory, "inflight", tellId));
+    const frames = originals.map((original, index) => `--- tell ${tellIds[index]} ---\n${original.text}`);
+    const effort = originals.reduce((value, original) => original.effort ?? value, undefined);
+    return { prompt: `${prompt}\n\n${frames.join("\n\n")}`, tellIds, ...(effort ? { effort } : {}) };
+}
+/** Tier-2 has no steer acknowledgement: actual driver start is its ordinal-zero submission point. */
+export function markReplayStarted(projectionDirectory, executionId, tellIds) {
+    for (const tellId of tellIds) {
+        if (listTellIds(projectionDirectory, "inflight").includes(tellId)) {
+            markTellSubmitted(projectionDirectory, tellId, { executionId, fence: { kind: "ordinal", ordinal: 0 } });
+        }
+    }
+}
+/** A successful replay terminal is checkpoint ordinal one; failures intentionally do not consume. */
+export function markReplayCompleted(projectionDirectory, executionId) {
+    for (const tellId of listTellIds(projectionDirectory, "submitted")) {
+        const submitted = readTellSubmitted(projectionDirectory, tellId);
+        if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, { kind: "ordinal", ordinal: 1 })) {
+            markTellConsumed(projectionDirectory, tellId);
+        }
+    }
+}
+/**
+ * Tier-2's only submission acknowledgement. A created driver is deliberately
+ * insufficient: observe the first provider event, or a successful completion
+ * from a provider that emitted no events.
+ */
+export function createReplayRunStartGate(projectionDirectory, executionId, tellIds) {
+    let started = false;
+    const start = () => {
+        if (started)
+            return;
+        markReplayStarted(projectionDirectory, executionId, tellIds);
+        started = true;
+    };
+    return { observeProviderEvent: start, observeSuccessfulCompletion: start };
+}
+/** Heartbeat throttle: no more than one utimes call per 5000ms. */
+export const HEARTBEAT_MIN_INTERVAL_MS = 5_000;
+/**
+ * Supervisor pump: iterates handle.events, forwards to publicChannel,
+ * touches heartbeat (throttled), checks inbox at checkpoints,
+ * and on final sweep publishes verdict.
+ */
+export async function pumpSupervisor(handle, projectionDirectory, publicChannel, onEvent) {
+    let lastHeartbeatMs = 0;
+    let heartbeatDegraded = false;
+    const heartbeat = () => {
+        const now = Date.now();
+        if (now - lastHeartbeatMs < HEARTBEAT_MIN_INTERVAL_MS)
+            return;
+        lastHeartbeatMs = now;
+        try {
+            touchHeartbeatFile(projectionDirectory, now);
+            heartbeatDegraded = false;
+        }
+        catch (error) {
+            if (!heartbeatDegraded) {
+                publicChannel.push({
+                    type: "diagnostic",
+                    text: `heartbeat degraded: ${String(error)}`,
+                });
+            }
+            heartbeatDegraded = true;
+        }
+    };
+    const heartbeatTimer = setInterval(heartbeat, HEARTBEAT_MIN_INTERVAL_MS);
+    const stopHeartbeatTimer = () => clearInterval(heartbeatTimer);
+    try {
+        for await (const event of handle.events) {
+            publicChannel.push(event);
+            onEvent?.(event);
+            heartbeat();
+            if (event.type === "done" || event.type === "fail")
+                stopHeartbeatTimer();
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.code === "PROJECTION_STATE_ERROR") {
+            publicChannel.push({
+                type: "fail",
+                code: "PROJECTION_STATE_ERROR",
+                message: error.message,
+            });
+        }
+        else {
+            publicChannel.push({
+                type: "diagnostic",
+                text: `pump error: ${String(error)}`,
+            });
+        }
+    }
+    finally {
+        stopHeartbeatTimer();
+    }
+}
+function readTellOriginalText(projectionDirPath, tellId, layer = "inflight") {
+    const content = JSON.parse(fs.readFileSync(path.join(projectionDirPath, layer, tellId), "utf8"));
+    return content.text;
+}
+/**
+ * Build an onSyncCheckpoint callback that claims all inbox tells
+ * and delivers them via the given SteerControl.
+ * Intended for use inside adapter start() calls as the onSyncCheckpoint callback.
+ */
+export function buildSyncCheckpointCallback(projectionDirectory) {
+    const submitting = new Set();
+    return (control, checkpoint) => {
+        claimAllInbox(projectionDirectory);
+        const executionId = readAdmissionLock(projectionDirectory)?.executionId;
+        for (const tellId of listTellIds(projectionDirectory, "inflight")) {
+            if (submitting.has(tellId))
+                continue;
+            submitting.add(tellId);
+            const original = readTellOriginal(projectionDirectory, "inflight", tellId);
+            const originalText = original.text;
+            const tell = {
+                id: tellId,
+                text: `--- tell ${tellId} ---\n${originalText}`,
+                ...(original.effort ? { effort: original.effort } : {}),
+            };
+            void control.enqueue(tell)
+                .then((ack) => {
+                if (!executionId)
+                    throw new Error("projection checkpoint has no execution admission");
+                if (!ack)
+                    throw new Error("provider enqueue resolved without TellSubmitAck");
+                markTellSubmitted(projectionDirectory, tellId, { executionId, fence: ack.fence });
+            })
+                .catch(() => {
+                // Leave in inflight for the next checkpoint.
+            })
+                .finally(() => submitting.delete(tellId));
+        }
+        if (!executionId)
+            return;
+        for (const tellId of listTellIds(projectionDirectory, "submitted")) {
+            const submitted = readTellSubmitted(projectionDirectory, tellId);
+            if (submitted.executionId === executionId && submitted.fence && isTellCausallyConsumed(submitted.fence, checkpoint.fence)) {
+                markTellConsumed(projectionDirectory, tellId);
+            }
+        }
+    };
+}

package/build/agents/harness/runtime.js

@@ -0,0 +1,68 @@
+import { createHash } from "node:crypto";
+import { getConfig } from "../../config/env.js";
+import { DISABLE_SUBAGENT_SPAWN_ENV_KEY } from "../../config/env-keys.js";
+export function sha256Utf8(value) {
+    const bytes = Buffer.from(value, "utf8");
+    return { sha256: createHash("sha256").update(bytes).digest("hex"), byteLength: bytes.byteLength };
+}
+/**
+ * Observer calls are synchronous at the native boundary. Their return values
+ * never gate provider progress; rejected thenables are reduced to diagnostics.
+ */
+export function emitProviderEvidence(callback, evidence, diagnostic) {
+    if (!callback)
+        return;
+    const reportFailure = () => {
+        try {
+            diagnostic?.("provider evidence callback failed");
+        }
+        catch {
+            // Evidence and its diagnostics are observation-only.
+        }
+    };
+    try {
+        const returned = callback(evidence);
+        if (returned !== null &&
+            (typeof returned === "object" || typeof returned === "function") &&
+            "then" in returned &&
+            typeof returned.then === "function") {
+            void Promise.resolve(returned).catch(reportFailure);
+        }
+    }
+    catch {
+        reportFailure();
+    }
+}
+export function createAbortError(message) {
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
+}
+export function renderTruncationSuffix(truncatedChars) {
+    if (truncatedChars <= 0)
+        return "";
+    return `\n...[truncated ${truncatedChars} chars from start]...`;
+}
+export function renderCapturedText(buffer) {
+    const snapshot = buffer.snapshot();
+    return `${snapshot.text}${renderTruncationSuffix(snapshot.truncatedChars)}`;
+}
+export function linkAbortSignal(signal, controller, onAbort) {
+    if (!signal)
+        return undefined;
+    const handler = () => {
+        onAbort();
+        controller.abort(signal.reason);
+    };
+    signal.addEventListener("abort", handler, { once: true });
+    if (signal.aborted) {
+        handler();
+    }
+    return () => signal.removeEventListener("abort", handler);
+}
+export function buildSubagentEnv() {
+    return {
+        ...getConfig().runtimeEnv,
+        [DISABLE_SUBAGENT_SPAWN_ENV_KEY]: "1",
+    };
+}

package/build/agents/index.js

@@ -1,222 +1,114 @@
-import { z } from "zod";
 import { FlowError } from "../flow-error.js";
-import { getAvailableAgentNames, loadKeiyakuSettings, normalizeAgentProfile, resolveAgentProfile, } from "../config/settings.js";
-import { runClaudeAgentSdkExec } from "./claude-agent-sdk-exec.js";
-import { runCodexCliExec } from "./codex-cli-exec.js";
-import { runCodexSdkExec } from "./codex-sdk-exec.js";
-import { runGeminiCliCoreExec } from "./gemini-cli-core-exec.js";
-import { runOpencodeExec } from "./opencode-exec.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "./types.js";
-export { SubagentExecError, isSubagentExecError } from "./types.js";
-const codexThreadHandleSchema = z.object({ threadId: z.string().trim().min(1) });
-const claudeSessionHandleSchema = z.object({ sessionId: z.string().trim().min(1) });
-const geminiSessionHandleSchema = z.object({ sessionId: z.string().trim().min(1) });
-const opencodeSessionHandleSchema = z.object({ sessionId: z.string().trim().min(1) });
-const codexCliAdapter = {
-    provider: "codex-cli",
-    handleSchema: codexThreadHandleSchema,
-    async run(prompt, cwd, config) {
-        const result = await runCodexCliExec(prompt, cwd, {
-            model: config.model,
-            profile: config.profile,
-            config: config.config,
-            executable: config.executable,
-            signal: config.signal,
-        });
-        return result;
-    },
-    async resume(prompt, cwd, config, handle) {
-        const result = await runCodexCliExec(prompt, cwd, {
-            model: config.model,
-            profile: config.profile,
-            config: config.config,
-            executable: config.executable,
-            signal: config.signal,
-            threadId: handle.threadId,
-        });
-        return result;
-    },
-};
-const codexSdkAdapter = {
-    provider: "codex-sdk",
-    handleSchema: codexThreadHandleSchema,
-    async run(prompt, cwd, config) {
-        const result = await runCodexSdkExec(prompt, cwd, {
-            model: config.model,
-            profile: config.profile,
-            config: config.config,
-            executable: config.executable,
-            signal: config.signal,
-        });
-        return result;
-    },
-    async resume(prompt, cwd, config, handle) {
-        const result = await runCodexSdkExec(prompt, cwd, {
-            model: config.model,
-            profile: config.profile,
-            config: config.config,
-            executable: config.executable,
-            signal: config.signal,
-            threadId: handle.threadId,
-        });
-        return result;
-    },
-};
-const claudeAgentSdkAdapter = {
-    provider: "claude-agent-sdk",
-    handleSchema: claudeSessionHandleSchema,
-    async run(prompt, cwd, config) {
-        const result = await runClaudeAgentSdkExec(prompt, cwd, {
-            model: config.model,
-            executable: config.executable,
-            effort: config.effort,
-            signal: config.signal,
-            permissionMode: config.permissionMode,
-            settingSources: config.settingSources,
-            systemPromptFile: config.systemPromptFile,
-        });
-        return result;
-    },
-    async resume(prompt, cwd, config, handle) {
-        const result = await runClaudeAgentSdkExec(prompt, cwd, {
-            model: config.model,
-            executable: config.executable,
-            effort: config.effort,
-            signal: config.signal,
-            permissionMode: config.permissionMode,
-            settingSources: config.settingSources,
-            systemPromptFile: config.systemPromptFile,
-            sessionId: handle.sessionId,
-        });
-        return result;
-    },
-};
-const geminiCliCoreAdapter = {
-    provider: "gemini-cli-core",
-    handleSchema: geminiSessionHandleSchema,
-    run(prompt, cwd, config) {
-        return runGeminiCliCoreExec(prompt, cwd, {
-            model: config.model,
-            signal: config.signal,
-            systemPromptFile: config.systemPromptFile,
-        });
-    },
-    resume(prompt, cwd, config, handle) {
-        return runGeminiCliCoreExec(prompt, cwd, {
-            model: config.model,
-            signal: config.signal,
-            sessionId: handle.sessionId,
-            systemPromptFile: config.systemPromptFile,
-        });
-    },
-};
-const opencodeSdkAdapter = {
-    provider: "opencode-sdk",
-    handleSchema: opencodeSessionHandleSchema,
-    async run(prompt, cwd, config) {
-        const result = await runOpencodeExec(prompt, cwd, {
-            model: config.model,
-            executable: config.executable,
-            signal: config.signal,
-        });
-        return result;
-    },
-    async resume(prompt, cwd, config, handle) {
-        const result = await runOpencodeExec(prompt, cwd, {
-            model: config.model,
-            executable: config.executable,
-            signal: config.signal,
-            sessionId: handle.sessionId,
-        });
-        return result;
-    },
-};
-const SUBAGENT_ADAPTERS = {
-    "codex-cli": codexCliAdapter,
-    "codex-sdk": codexSdkAdapter,
-    "claude-agent-sdk": claudeAgentSdkAdapter,
-    "gemini-cli-core": geminiCliCoreAdapter,
-    "opencode-sdk": opencodeSdkAdapter,
-};
-function getSubagentAdapter(provider) {
-    return SUBAGENT_ADAPTERS[provider];
+import { EFFORT_LEVELS } from "../keiyaku.js";
+import { resolveEffectiveCodexSdkProfile } from "./effective-policy.js";
+import { getConfig } from "../config/env.js";
+import { selectSubagent } from "./selector.js";
+export { formatAvailableAgentNames } from "./selector.js";
+export function createAbortError(message) {
+    const error = new Error(message);
+    error.name = "AbortError";
+    return error;
 }
-function parseSessionEnvelopeText(sessionText, resumePath) {
-    let parsedSession;
-    try {
-        parsedSession = JSON.parse(sessionText);
-    }
-    catch {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes invalid 'session' metadata; this conversation cannot be resumed.`);
-    }
-    const sessionResult = subagentSessionEnvelopeSchema.safeParse(parsedSession);
-    if (!sessionResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes invalid 'session' metadata; this conversation cannot be resumed.`);
-    }
-    return sessionResult.data;
+export function coerceString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
-export function resolvePersistedSubagentSession(input) {
-    const sessionText = input.sessionText?.trim();
-    if (sessionText) {
-        return parseSessionEnvelopeText(sessionText, input.resumePath);
-    }
-    return undefined;
+function codexEffort(config) {
+    const value = config?.model_reasoning_effort;
+    return typeof value === "string" && EFFORT_LEVELS.includes(value) ? value : undefined;
 }
-function validateResumeSession(adapter, session, resumePath) {
-    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
-    if (!envelopeResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
-    }
-    if (session.provider !== adapter.provider) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${adapter.provider}'. Cross-provider resume is not supported.`);
-    }
-    if (session.version !== SUBAGENT_SESSION_VERSION) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
-    }
-    const handleResult = adapter.handleSchema.safeParse(session.handle);
-    if (!handleResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
-    }
-    return handleResult.data;
+export async function resolveSubagentConfig(agentName, cwd) {
+    return (await selectSubagent(agentName, cwd)).profile;
 }
-function formatAvailableAgentNames(names) {
-    return names.length > 0 ? names.join(", ") : "(none configured)";
+function maxCaptureCharsForProvider(provider) {
+    const config = getConfig();
+    switch (provider) {
+        case "codex-sdk":
+            return config.codex.execMaxCaptureChars;
+        case "codex-app-server":
+            return config.codex.execMaxCaptureChars;
+        case "claude-agent-sdk":
+            return config.claude.execMaxCaptureChars;
+        case "opencode-sdk":
+            return config.opencode.execMaxCaptureChars;
+        case "pi":
+            return config.codex.execMaxCaptureChars;
+    }
 }
-function createSyntheticSession(provider) {
-    const handle = provider === "codex-cli" || provider === "codex-sdk"
-        ? { threadId: `fake-${provider}-thread` }
-        : { sessionId: `fake-${provider}-session` };
-    return {
-        provider,
-        version: SUBAGENT_SESSION_VERSION,
-        handle,
+export function buildSummonTerms(config, prompt, cwd, options) {
+    const runtimeConfig = getConfig();
+    const baseTerms = {
+        workdir: cwd,
+        prompt,
+        timeoutMs: options.timeoutMs ?? runtimeConfig.subagent.execTimeoutMs,
+        idleTimeoutMs: options.idleTimeoutMs ?? runtimeConfig.subagent.execIdleTimeoutMs,
+        maxCaptureChars: maxCaptureCharsForProvider(config.provider),
+        signal: options.signal,
+        projectionDir: options.projectionDir,
+        projectionExecutionId: options.projectionExecutionId,
     };
-}
-export function createSyntheticSessionForProvider(provider) {
-    return createSyntheticSession(provider);
-}
-export async function resolveSubagentConfig(agentName, cwd) {
-    const settings = await loadKeiyakuSettings(cwd);
-    const availableNames = getAvailableAgentNames(settings);
-    if (!availableNames.includes(agentName)) {
-        throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${agentName}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
-    }
-    try {
-        return normalizeAgentProfile(resolveAgentProfile(settings, agentName));
-    }
-    catch (error) {
-        if (error instanceof FlowError && error.code === "UNKNOWN_SUBAGENT") {
-            throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${agentName}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
-        }
-        throw error;
+    const body = options.akumaBody;
+    const replayPrompt = body ? `[Akuma system prompt]\n${body}\n\n[Operator prompt]\n${prompt}` : prompt;
+    switch (config.provider) {
+        case "codex-sdk":
+            {
+                const effective = "effectivePolicy" in config && config.threadOptions
+                    ? config
+                    : resolveEffectiveCodexSdkProfile(config, cwd, {});
+                return {
+                    ...baseTerms, prompt: replayPrompt,
+                    provider: "codex-sdk",
+                    model: effective.model,
+                    profile: effective.profile,
+                    config: effective.config,
+                    threadOptions: effective.threadOptions,
+                    effectivePolicy: effective.effectivePolicy,
+                    executable: effective.executable,
+                };
+            }
+        case "codex-app-server":
+            return {
+                ...baseTerms,
+                provider: "codex-app-server",
+                model: config.model,
+                effort: codexEffort(config.config),
+                profile: config.profile,
+                config: config.config,
+                executable: config.executable,
+                developerInstructions: body || undefined,
+                onCheckpoint() { },
+            };
+        case "claude-agent-sdk":
+            return {
+                ...baseTerms,
+                provider: "claude-agent-sdk",
+                model: config.model,
+                executable: config.executable,
+                effort: config.effort,
+                permissionMode: config.permissionMode,
+                settingSources: config.settingSources,
+                systemPrompt: body ? { type: "preset", preset: "claude_code", append: body } : undefined,
+                onCheckpoint() { },
+            };
+        case "opencode-sdk":
+            return {
+                ...baseTerms, prompt: replayPrompt,
+                provider: "opencode-sdk",
+                model: config.model,
+                executable: config.executable,
+            };
+        case "pi":
+            return {
+                ...baseTerms,
+                provider: "pi",
+                model: config.model,
+                thinkingLevel: config.thinkingLevel,
+                appendSystemPromptOverride: body ? () => [body] : undefined,
+                onCheckpoint() { },
+            };
+        default:
+            return assertNever(config);
     }
 }
-export async function runSubagentExec(agentName, prompt, cwd, options = {}) {
-    const config = await resolveSubagentConfig(agentName, cwd);
-    const adapter = SUBAGENT_ADAPTERS[config.provider];
-    if (!options.resume) {
-        return adapter.run(prompt, cwd, { ...config, signal: options.signal });
-    }
-    const handle = validateResumeSession(adapter, options.resume.session, options.resume.resumePath);
-    return adapter.resume(prompt, cwd, { ...config, signal: options.signal }, handle);
+function assertNever(_value) {
+    throw new FlowError("INVALID_SETTINGS", "Unsupported subagent provider.");
 }

package/build/agents/opencode-sdk.js

@@ -1,5 +1,7 @@
 import { spawn } from "node:child_process";
 import net from "node:net";
+import { coerceString } from "./index.js";
+import { createAbortError } from "./harness/runtime.js";
 const DEFAULT_HOSTNAME = "127.0.0.1";
 const DEFAULT_PORT = 4096;
 const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
@@ -21,22 +23,14 @@ const EVENT_DATA_PREFIX = "data:";
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function coerceString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
-}
 function normalizeBaseUrl(baseUrl) {
     return coerceString(baseUrl)?.replace(/\/+$/, "") ?? `http://${DEFAULT_HOSTNAME}:${DEFAULT_PORT}`;
 }
-function createAbortError(message) {
-    const error = new Error(message);
-    error.name = "AbortError";
-    return error;
-}
 function buildSessionPath(sessionId) {
     return `${SESSION_PATH}/${encodeURIComponent(sessionId)}`;
 }
-async function createJsonRequest(fetchImpl, baseUrl, requestPath, init = {}) {
-    const response = await fetchImpl(`${baseUrl}${requestPath}`, {
+async function createJsonRequest(fetcher, baseUrl, requestPath, init = {}) {
+    const response = await fetcher(`${baseUrl}${requestPath}`, {
         ...init,
         headers: {
             [RESPONSE_HEADER_ACCEPT]: JSON_CONTENT_TYPE,
@@ -95,40 +89,40 @@ function createSseStream(response) {
     };
 }
 export function createOpencodeClient(options = {}) {
-    const fetchImpl = options.fetch ?? globalThis.fetch;
-    if (typeof fetchImpl !== "function") {
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (typeof fetcher !== "function") {
         throw new Error("OpenCode SDK requires global fetch support");
     }
     const baseUrl = normalizeBaseUrl(options.baseUrl);
     return {
         config: {
             async get() {
-                return createJsonRequest(fetchImpl, baseUrl, CONFIG_PATH);
+                return createJsonRequest(fetcher, baseUrl, CONFIG_PATH);
             },
         },
         session: {
             async create(input = {}) {
-                return createJsonRequest(fetchImpl, baseUrl, SESSION_PATH, {
+                return createJsonRequest(fetcher, baseUrl, SESSION_PATH, {
                     method: "POST",
                     body: JSON.stringify(input.body ?? {}),
                 });
             },
             async get(input) {
-                return createJsonRequest(fetchImpl, baseUrl, buildSessionPath(input.path.id));
+                return createJsonRequest(fetcher, baseUrl, buildSessionPath(input.path.id));
             },
             async prompt(input) {
-                return createJsonRequest(fetchImpl, baseUrl, `${buildSessionPath(input.path.id)}${SESSION_MESSAGE_PATH_SUFFIX}`, {
+                return createJsonRequest(fetcher, baseUrl, `${buildSessionPath(input.path.id)}${SESSION_MESSAGE_PATH_SUFFIX}`, {
                     method: "POST",
                     body: JSON.stringify(input.body),
                 });
             },
             async messages(input) {
-                return createJsonRequest(fetchImpl, baseUrl, `${buildSessionPath(input.path.id)}${SESSION_MESSAGE_PATH_SUFFIX}`);
+                return createJsonRequest(fetcher, baseUrl, `${buildSessionPath(input.path.id)}${SESSION_MESSAGE_PATH_SUFFIX}`);
             },
         },
         event: {
             async subscribe() {
-                const response = await fetchImpl(`${baseUrl}${EVENT_PATH}`, {
+                const response = await fetcher(`${baseUrl}${EVENT_PATH}`, {
                     method: "GET",
                     headers: {
                         [RESPONSE_HEADER_ACCEPT]: EVENT_STREAM_CONTENT_TYPE,