@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/agents/providers/claude-agent-sdk/registration.js

@@ -1,225 +0,0 @@
-import { z } from "zod";
-import { claudeSettingSourceSchema, executableSchema, providerCommonFields, providerEnvSchema, } from "../../../config/settings/provider-instance-fields.js";
-import { FlowError } from "../../../flow-error.js";
-import { exactKeys, optionalString, optionalStringRecord, requiredEnum, snapshotError, } from "../../launch-snapshot/parse-helpers.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
-import { CLAUDE_AGENT_SDK_PROVIDER } from "./session.js";
-import { claudeSessionSchema } from "./session-schema.js";
-const startClaudeAgentSdk = async (prompt, cwd, options) => {
-    const { startClaudeAgentSdk: start } = await import("./adapter.js");
-    return start(prompt, cwd, options);
-};
-const CLAUDE_SETTING_SOURCES = new Set(["project", "user", "local"]);
-const ACCESS_VALUES = ["read", "write", "auto"];
-function admitResumeShape(schema, 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 !== CLAUDE_AGENT_SDK_PROVIDER) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${CLAUDE_AGENT_SDK_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 shapeResult = schema.safeParse(session.handle);
-    if (!shapeResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
-    }
-    return shapeResult.data;
-}
-export const claudeAgentSdkRegistration = {
-    name: CLAUDE_AGENT_SDK_PROVIDER,
-    start: startClaudeAgentSdk,
-    sessionSchema: claudeSessionSchema,
-    effortField: "effort",
-    instanceSchema: z
-        .object({
-        kind: z.literal(CLAUDE_AGENT_SDK_PROVIDER),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        settingSources: z.array(claudeSettingSourceSchema).optional(),
-        env: providerEnvSchema,
-    })
-        .strict(),
-    builtinInstance: {
-        name: CLAUDE_AGENT_SDK_PROVIDER,
-        source: "builtin",
-        instance: {
-            kind: CLAUDE_AGENT_SDK_PROVIDER,
-            executable: "claude",
-            settingSources: ["project"],
-        },
-    },
-    builtinAkumaProfiles: [
-        { name: "akuma-claude", description: "Default Claude Agent SDK Akuma." },
-    ],
-    portablePolicy: {
-        access: new Set(ACCESS_VALUES),
-        network: new Set(),
-        webSearch: new Set(["disabled"]),
-    },
-    maxCaptureChars: (config) => config.claude.execMaxCaptureChars,
-    buildCallTerms: ({ snapshot, baseTerms, body }) => {
-        const provider = snapshot.provider;
-        return {
-            ...baseTerms,
-            provider: CLAUDE_AGENT_SDK_PROVIDER,
-            ...(provider.model !== undefined ? { model: provider.model } : {}),
-            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
-            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
-            ...(provider.settingSources !== undefined ? { settingSources: provider.settingSources } : {}),
-            permissionMode: provider.permissionMode,
-            ...(provider.allowDangerouslySkipPermissions !== undefined
-                ? { allowDangerouslySkipPermissions: provider.allowDangerouslySkipPermissions }
-                : {}),
-            ...(provider.disallowedTools !== undefined ? { disallowedTools: provider.disallowedTools } : {}),
-            ...(provider.env !== undefined ? { env: provider.env } : {}),
-            systemPrompt: body
-                ? { type: "preset", preset: "claude_code", append: body }
-                : undefined,
-            onCheckpoint() { },
-        };
-    },
-    resolveLaunchProvider: ({ common, instance, model, effort, access, webSearch }) => {
-        if (instance.kind !== CLAUDE_AGENT_SDK_PROVIDER) {
-            throw new Error(`resolveLaunchProvider expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
-        }
-        const claudeInstance = instance;
-        const permissionMode = access === "read"
-            ? "plan"
-            : access === "write"
-                ? "acceptEdits"
-                : access === "auto"
-                    ? "bypassPermissions"
-                    : "default";
-        return Object.freeze({
-            ...common,
-            kind: CLAUDE_AGENT_SDK_PROVIDER,
-            ...(claudeInstance.executable !== undefined ? { executable: claudeInstance.executable } : {}),
-            ...(model !== undefined ? { model } : {}),
-            ...(effort !== undefined ? { effort } : {}),
-            ...(claudeInstance.settingSources !== undefined ? { settingSources: claudeInstance.settingSources } : {}),
-            permissionMode,
-            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
-            ...(webSearch === "disabled" ? { disallowedTools: ["WebSearch"] } : {}),
-            ...(claudeInstance.env !== undefined ? { env: claudeInstance.env } : {}),
-        });
-    },
-    parseLaunchProvider: (provider, common) => {
-        exactKeys(provider, [
-            "name",
-            "source",
-            "kind",
-            "executable",
-            "model",
-            "effort",
-            "settingSources",
-            "permissionMode",
-            "allowDangerouslySkipPermissions",
-            "disallowedTools",
-            "env",
-        ], "provider");
-        const modes = new Set(["default", "plan", "acceptEdits", "bypassPermissions"]);
-        const permissionMode = requiredEnum(provider, "permissionMode", "provider", modes);
-        if (permissionMode === "bypassPermissions") {
-            if (provider.allowDangerouslySkipPermissions !== true) {
-                throw snapshotError("provider.allowDangerouslySkipPermissions", "must be true for bypassPermissions");
-            }
-        }
-        else if ("allowDangerouslySkipPermissions" in provider) {
-            throw snapshotError("provider.allowDangerouslySkipPermissions", "is only valid for bypassPermissions");
-        }
-        let settingSources;
-        if ("settingSources" in provider) {
-            if (!Array.isArray(provider.settingSources))
-                throw snapshotError("provider.settingSources", "must be an array");
-            settingSources = Object.freeze(provider.settingSources.map((source, index) => {
-                if (typeof source !== "string" || !CLAUDE_SETTING_SOURCES.has(source)) {
-                    throw snapshotError(`provider.settingSources[${index}]`, "has an invalid setting source");
-                }
-                return source;
-            }));
-        }
-        let disallowedTools;
-        if ("disallowedTools" in provider) {
-            if (!Array.isArray(provider.disallowedTools) ||
-                provider.disallowedTools.length !== 1 ||
-                provider.disallowedTools[0] !== "WebSearch") {
-                throw snapshotError("provider.disallowedTools", "must equal ['WebSearch']");
-            }
-            disallowedTools = Object.freeze(["WebSearch"]);
-        }
-        const executable = optionalString(provider, "executable", "provider");
-        const model = optionalString(provider, "model", "provider");
-        const effort = optionalString(provider, "effort", "provider");
-        const env = optionalStringRecord(provider, "env");
-        return Object.freeze({
-            ...common,
-            kind: CLAUDE_AGENT_SDK_PROVIDER,
-            ...(executable !== undefined ? { executable } : {}),
-            ...(model !== undefined ? { model } : {}),
-            ...(effort !== undefined ? { effort } : {}),
-            ...(settingSources !== undefined ? { settingSources } : {}),
-            permissionMode,
-            ...(permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
-            ...(disallowedTools !== undefined ? { disallowedTools } : {}),
-            ...(env !== undefined ? { env } : {}),
-        });
-    },
-    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
-    providerEffortAndModel: (provider) => {
-        const resolved = provider;
-        return { model: resolved.model, effort: resolved.effort };
-    },
-    attachLoader: (terms, ports) => {
-        if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER)
-            return terms;
-        const loader = ports.claudeAgentSdk;
-        return loader ? { ...terms, loader } : terms;
-    },
-    nativePolicyOwnership: () => null,
-    tellReceiptCapabilities: { seen: "exact", consumed: "fence" },
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onSessionAdmission, onIngress, launchTellIds, observer }) => {
-        if (terms.provider !== CLAUDE_AGENT_SDK_PROVIDER) {
-            throw new Error(`startLive expected ${CLAUDE_AGENT_SDK_PROVIDER}`);
-        }
-        const claudeTerms = terms;
-        const claudeOptions = {
-            model: claudeTerms.model,
-            executable: claudeTerms.executable,
-            effort: claudeTerms.effort,
-            env: claudeTerms.env,
-            signal,
-            permissionMode: claudeTerms.permissionMode,
-            settingSources: claudeTerms.settingSources,
-            allowDangerouslySkipPermissions: claudeTerms.allowDangerouslySkipPermissions,
-            disallowedTools: claudeTerms.disallowedTools,
-            systemPrompt: claudeTerms.systemPrompt,
-            onSyncCheckpoint,
-            onTellReceipt: observer ? (receipt) => {
-                try {
-                    observer.onTellReceipt(receipt);
-                }
-                catch { /* Receipt persistence cannot alter provider control. */ }
-            } : undefined,
-            launchTellIds,
-            onLaunchAdmission: observer ? (admission) => observer.onLaunchAdmission(admission) : undefined,
-            listLaunchAdmissions: observer ? () => observer.listLaunchAdmissions() : undefined,
-            onEvidence: claudeTerms.onEvidence,
-            onSessionAdmission,
-            onIngress,
-            initialTurn: claudeTerms.initialTurn,
-            loader: claudeTerms.loader,
-        };
-        const { startClaudeAgentSdk: start } = await import("./adapter.js");
-        if (reviveTerms) {
-            const session = admitResumeShape(claudeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-            return start(claudeTerms.prompt, claudeTerms.workdir, {
-                ...claudeOptions,
-                sessionId: session.sessionId,
-            });
-        }
-        return start(claudeTerms.prompt, claudeTerms.workdir, claudeOptions);
-    },
-};

package/build/agents/providers/claude-agent-sdk/session-schema.js

@@ -1,2 +0,0 @@
-import { z } from "zod";
-export const claudeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });

package/build/agents/providers/claude-agent-sdk/session.js

@@ -1,172 +0,0 @@
-export const CLAUDE_AGENT_SDK_PROVIDER = "claude-agent-sdk";
-/** Sentinel for IteratorResult<SDKUserMessage> done=true returns.
- * The SDK's AsyncIterator protocol requires the value field even when done=true.
- * Consumers never read it, but TypeScript needs the type to match. */
-const DONE_SENTINEL = undefined;
-function createMessageAck() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    // Prevent unhandled rejection if nobody awaits before reject-on-end.
-    promise.catch(() => undefined);
-    const ack = {
-        settled: false,
-        settleResolve() {
-            if (ack.settled)
-                return;
-            ack.settled = true;
-            resolve();
-        },
-        settleReject(error) {
-            if (ack.settled)
-                return;
-            ack.settled = true;
-            reject(error);
-        },
-        wait() {
-            return promise;
-        },
-    };
-    return ack;
-}
-/**
- * Long-lived push source for Claude Query.
- * Submitted fence is per-yield: entering next() first acknowledges the previously
- * yielded message, then yields the next item. That next-entry after a yield is the
- * post-yield ack (transport.write completed for the prior yield).
- */
-export function createPushableUserMessageStream(onYield) {
-    const queue = [];
-    const waiters = [];
-    /** Ack for the message most recently yielded; resolved on the subsequent next() entry. */
-    let pendingYieldAck;
-    let closed = false;
-    let failure;
-    let pullCount = 0;
-    const terminalError = (error) => error ?? new Error(`${CLAUDE_AGENT_SDK_PROVIDER} input stream ended before submitted ack`);
-    const rejectUnresolvedAcks = (error) => {
-        const err = terminalError(error);
-        if (pendingYieldAck) {
-            pendingYieldAck.settleReject(err);
-            pendingYieldAck = undefined;
-        }
-        while (queue.length > 0) {
-            queue.shift().ack.settleReject(err);
-        }
-    };
-    /** First action on every next() entry: post-yield ack for the prior yield. */
-    const acknowledgePreviousYield = () => {
-        if (!pendingYieldAck)
-            return;
-        pendingYieldAck.settleResolve();
-        pendingYieldAck = undefined;
-    };
-    const yieldQueued = async (entry) => {
-        pullCount += 1;
-        pendingYieldAck = entry.ack;
-        try {
-            await onYield?.(entry.message);
-        }
-        catch (error) {
-            // A source-pull rejection means the SDK never received this item. Reject
-            // its post-yield acknowledgement before surfacing the provider failure.
-            entry.ack.settleReject(error);
-            if (pendingYieldAck === entry.ack)
-                pendingYieldAck = undefined;
-            throw error;
-        }
-        return { value: entry.message, done: false };
-    };
-    return {
-        get pullCount() {
-            return pullCount;
-        },
-        get queueLength() {
-            return queue.length;
-        },
-        push(message) {
-            const ack = createMessageAck();
-            if (closed || failure !== undefined) {
-                ack.settleReject(terminalError(failure));
-                return { waitSubmitted: () => ack.wait() };
-            }
-            const waiter = waiters.shift();
-            if (waiter) {
-                // Consumer is already inside next() (previous yield already acked at entry).
-                pullCount += 1;
-                pendingYieldAck = ack;
-                void Promise.resolve(onYield?.(message)).then(() => waiter.resolve({ value: message, done: false }), (error) => {
-                    ack.settleReject(error);
-                    if (pendingYieldAck === ack)
-                        pendingYieldAck = undefined;
-                    waiter.reject(error);
-                });
-                return { waitSubmitted: () => ack.wait() };
-            }
-            queue.push({ message, ack });
-            return { waitSubmitted: () => ack.wait() };
-        },
-        end(error) {
-            if (closed)
-                return;
-            closed = true;
-            if (error !== undefined) {
-                failure = error;
-                // Failure: reject every unresolved ack (yielded + still queued) so enqueue cannot hang.
-                rejectUnresolvedAcks(error);
-                while (waiters.length > 0) {
-                    waiters.shift().reject(failure);
-                }
-                return;
-            }
-            // Clean end: leave queued messages readable for a late consumer drain.
-            // Only reject a yielded-but-not-post-acked message (no further next() will ack it
-            // if the consumer has already stopped). If a consumer is parked, they get done
-            // after any remaining queue is taken on subsequent next() calls — parked waiters
-            // here mean queue is empty, so resolve done.
-            if (pendingYieldAck) {
-                pendingYieldAck.settleReject(terminalError());
-                pendingYieldAck = undefined;
-            }
-            while (waiters.length > 0) {
-                waiters.shift().resolve({ value: DONE_SENTINEL, done: true });
-            }
-        },
-        iterable: {
-            [Symbol.asyncIterator]() {
-                return {
-                    next() {
-                        // Per-yield submitted fence: next entry acks the previously yielded message.
-                        acknowledgePreviousYield();
-                        if (queue.length > 0) {
-                            return yieldQueued(queue.shift());
-                        }
-                        if (failure !== undefined) {
-                            return Promise.reject(failure);
-                        }
-                        if (closed) {
-                            return Promise.resolve({ value: DONE_SENTINEL, done: true });
-                        }
-                        return new Promise((resolve, reject) => {
-                            waiters.push({ resolve, reject });
-                        });
-                    },
-                };
-            },
-        },
-    };
-}
-export function toClaudeUserMessage(text) {
-    return {
-        type: "user",
-        message: {
-            role: "user",
-            content: text,
-        },
-        parent_tool_use_id: null,
-        session_id: "",
-    };
-}