@velum-labs/routekit-tool-claude 0.18.6 → 1.0.0

package/dist/driver.d.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
 import type { Options, Query } from "@anthropic-ai/claude-agent-sdk";
 import type { HarnessDriver } from "@velum-labs/routekit-harness-core";
+import { z } from "zod";
 export declare const claudeDriverConfigSchema: z.ZodObject<{
     command: z.ZodDefault<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;

package/dist/driver.js

@@ -1,6 +1,6 @@
-import { z } from "zod";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { HarnessError, DEFAULT_AUTOMATION_APPROVAL_POLICY, PendingRequests, asHarnessError, buildChildEnv, createCachedHarnessDriver, decideApproval, probeCliVersion, resolveDriverEnv } from "@velum-labs/routekit-harness-core";
+import { AsyncChannel, asHarnessError, buildChildEnv, createCachedHarnessDriver, DEFAULT_AUTOMATION_APPROVAL_POLICY, decideApproval, HarnessError, nowIso, PendingRequests, probeCliVersion, resolveDriverEnv, resumeStringField, SessionResourceRegistry, SingleFlightTurnController } from "@velum-labs/routekit-harness-core";
+import { z } from "zod";
 const RESUME_CURSOR_VERSION = 1;
 const DEFAULT_COMMAND = "claude";
 const AUTH_ENV_NAMES = [
@@ -18,9 +18,6 @@ export const claudeDriverConfigSchema = z.object({
     /** Extra credential env var names forwarded into the claude child. */
     credentialEnvNames: z.array(z.string()).default([])
 });
-function nowIso() {
-    return new Date().toISOString();
-}
 /**
  * The canonical approval request type for a claude tool name. Note `Task`
  * (Claude's sub-agent tool) deliberately lands in the generic `tool_approval`
@@ -50,6 +47,7 @@ class ClaudeSession {
     #sessionId;
     #activeQuery;
     #stopped = false;
+    #turns = new SingleFlightTurnController();
     #queryFn;
     constructor(input) {
         this.#config = input.config;
@@ -57,8 +55,7 @@ class ClaudeSession {
         this.#cwd = input.options.cwd;
         this.#model = input.options.model ?? input.config.model;
         this.#reasoning = input.options.reasoning;
-        this.#approvalPolicy =
-            input.options.approvalPolicy ?? DEFAULT_AUTOMATION_APPROVAL_POLICY;
+        this.#approvalPolicy = input.options.approvalPolicy ?? DEFAULT_AUTOMATION_APPROVAL_POLICY;
         this.#sessionId = resumeSessionId(input.options.resume) ?? "claude:pending";
         this.#queryFn = input.queryFn;
     }
@@ -116,109 +113,104 @@ class ClaudeSession {
         return decision;
     }
     #emit(event) {
-        this.#channel?.(event);
+        this.#channel?.push(event);
     }
     async *sendTurn(input) {
         if (this.#stopped)
             throw new HarnessError("session_closed", "claude session is stopped");
+        const turn = this.#turns.start(input.signal);
         const controller = new AbortController();
-        if (input.signal !== undefined) {
-            if (input.signal.aborted)
-                controller.abort(input.signal.reason);
-            else
-                input.signal.addEventListener("abort", () => controller.abort(input.signal?.reason), { once: true });
-        }
-        const resume = this.#sessionId !== "claude:pending" ? this.#sessionId : undefined;
-        const reasoning = input.reasoning ?? this.#reasoning;
-        const options = {
-            cwd: this.#cwd,
-            pathToClaudeCodeExecutable: this.#config.command,
-            // The gateway carries this cursor across front-door turns. Make the
-            // persistence requirement explicit: SDK defaults have changed across
-            // releases and an ephemeral session id cannot be resumed by the next
-            // candidate process.
-            persistSession: true,
-            permissionMode: "default",
-            canUseTool: this.#canUseTool(),
-            abortController: controller,
-            env: this.#childEnv(),
-            ...(this.#model !== undefined ? { model: this.#model } : {}),
-            ...(reasoning?.mode === "effort"
-                ? {
-                    thinking: { type: "adaptive" },
-                    effort: reasoning.effort
-                }
-                : reasoning?.mode === "budget"
-                    ? {
-                        thinking: {
-                            type: "enabled",
-                            budgetTokens: reasoning.budgetTokens
-                        }
-                    }
-                    : reasoning?.mode === "adaptive"
-                        ? { thinking: { type: "adaptive" } }
-                        : reasoning?.mode === "disabled"
-                            ? { thinking: { type: "disabled" } }
-                            : {}),
-            ...(resume !== undefined ? { resume } : {})
-        };
-        const queued = [];
-        let notify;
-        this.#channel = (event) => {
-            queued.push(event);
-            notify?.();
-        };
+        const onAbort = () => controller.abort(turn.signal.reason);
+        if (turn.signal.aborted)
+            onAbort();
+        else
+            turn.signal.addEventListener("abort", onAbort, { once: true });
+        const channel = new AsyncChannel({
+            capacity: 256,
+            onConsumerReturn: () => turn.dispose()
+        });
+        this.#channel = channel;
         const turnId = `${this.#sessionId}:turn:${Date.now()}`;
         // turn.started is emitted from mapMessage once system/init fixes the real
         // session id, so it (and every later event) carries the final id.
-        const q = this.#queryFn({ prompt: input.prompt, options });
-        this.#activeQuery = q;
+        let q;
+        let pump;
         let done = false;
-        let failure;
-        const pump = (async () => {
-            try {
-                for await (const message of q) {
-                    for (const event of this.#mapMessage(message, turnId))
-                        queued.push(event);
-                    notify?.();
-                }
-            }
-            catch (error) {
-                failure = error;
-            }
-            finally {
-                done = true;
-                notify?.();
-            }
-        })();
         try {
-            for (;;) {
-                if (queued.length > 0) {
-                    yield queued.shift();
-                    continue;
+            const resume = this.#sessionId !== "claude:pending" ? this.#sessionId : undefined;
+            const reasoning = input.reasoning ?? this.#reasoning;
+            const options = {
+                cwd: this.#cwd,
+                pathToClaudeCodeExecutable: this.#config.command,
+                // The gateway carries this cursor across front-door turns. Make the
+                // persistence requirement explicit: SDK defaults have changed across
+                // releases and an ephemeral session id cannot be resumed by the next
+                // candidate process.
+                persistSession: true,
+                permissionMode: "default",
+                canUseTool: this.#canUseTool(),
+                abortController: controller,
+                env: this.#childEnv(),
+                ...(this.#model !== undefined ? { model: this.#model } : {}),
+                ...(reasoning?.mode === "effort"
+                    ? {
+                        thinking: { type: "adaptive" },
+                        effort: reasoning.effort
+                    }
+                    : reasoning?.mode === "budget"
+                        ? {
+                            thinking: {
+                                type: "enabled",
+                                budgetTokens: reasoning.budgetTokens
+                            }
+                        }
+                        : reasoning?.mode === "adaptive"
+                            ? { thinking: { type: "adaptive" } }
+                            : reasoning?.mode === "disabled"
+                                ? { thinking: { type: "disabled" } }
+                                : {}),
+                ...(resume !== undefined ? { resume } : {})
+            };
+            q = this.#queryFn({ prompt: input.prompt, options });
+            this.#activeQuery = q;
+            pump = (async () => {
+                try {
+                    for await (const message of q) {
+                        for (const event of this.#mapMessage(message, turnId))
+                            channel.push(event);
+                    }
                 }
-                if (done)
-                    break;
-                await new Promise((resolve) => {
-                    notify = () => {
-                        notify = undefined;
-                        resolve();
-                    };
-                });
-            }
-            await pump;
-            if (failure !== undefined) {
-                const base = { kind: this.#kind, sessionId: this.#sessionId, at: nowIso(), turnId };
-                if (controller.signal.aborted) {
-                    yield { ...base, type: "turn.completed", endReason: "aborted" };
+                catch (error) {
+                    const base = { kind: this.#kind, sessionId: this.#sessionId, at: nowIso(), turnId };
+                    if (controller.signal.aborted) {
+                        channel.push({ ...base, type: "turn.completed", endReason: "aborted" });
+                    }
+                    else {
+                        const harnessError = asHarnessError(error);
+                        channel.push({
+                            ...base,
+                            type: "turn.failed",
+                            errorCode: harnessError.code,
+                            message: harnessError.message
+                        });
+                    }
                 }
-                else {
-                    const harnessError = asHarnessError(failure);
-                    yield { ...base, type: "turn.failed", errorCode: harnessError.code, message: harnessError.message };
+                finally {
+                    done = true;
+                    channel.close();
                 }
-            }
+            })();
+            yield* channel;
+            await pump;
         }
         finally {
+            if (done)
+                turn.complete();
+            turn.dispose();
+            turn.signal.removeEventListener("abort", onAbort);
+            if (!done)
+                await q?.interrupt().catch(() => undefined);
+            channel.close();
             this.#channel = undefined;
             this.#activeQuery = undefined;
         }
@@ -255,7 +247,13 @@ class ClaudeSession {
                     yield { ...base, type: "content.delta", stream: "assistant_text", text: block.text, raw };
                 }
                 else if (block.type === "thinking" && block.thinking !== undefined) {
-                    yield { ...base, type: "content.delta", stream: "reasoning_text", text: block.thinking, raw };
+                    yield {
+                        ...base,
+                        type: "content.delta",
+                        stream: "reasoning_text",
+                        text: block.thinking,
+                        raw
+                    };
                 }
                 else if (block.type === "tool_use") {
                     yield {
@@ -288,7 +286,9 @@ class ClaudeSession {
         return buildChildEnv({
             base: resolveDriverEnv(this.#context),
             allow: [...AUTH_ENV_NAMES, ...this.#config.credentialEnvNames, /^CLAUDE_/],
-            ...(this.#config.baseUrl !== undefined ? { extra: { ANTHROPIC_BASE_URL: this.#config.baseUrl } } : {})
+            ...(this.#config.baseUrl !== undefined
+                ? { extra: { ANTHROPIC_BASE_URL: this.#config.baseUrl } }
+                : {})
         });
     }
     async respondToRequest(requestId, decision) {
@@ -297,25 +297,30 @@ class ClaudeSession {
         }
     }
     async interrupt() {
+        this.#turns.interrupt();
         this.#pending.settleAll("cancel");
         await this.#activeQuery?.interrupt().catch(() => undefined);
     }
     resumeCursor() {
         if (this.#sessionId === "claude:pending")
             return undefined;
-        return { version: RESUME_CURSOR_VERSION, kind: this.#kind, data: { sessionId: this.#sessionId } };
+        return {
+            version: RESUME_CURSOR_VERSION,
+            kind: this.#kind,
+            data: { sessionId: this.#sessionId }
+        };
     }
     async stop() {
+        if (this.#stopped)
+            return;
         this.#stopped = true;
+        this.#turns.interrupt(new Error("claude session stopped"));
         this.#pending.settleAll("cancel");
         await this.#activeQuery?.interrupt().catch(() => undefined);
     }
 }
 function resumeSessionId(resume) {
-    if (resume === undefined || resume.kind !== "claude_code")
-        return undefined;
-    const data = resume.data;
-    return typeof data.sessionId === "string" ? data.sessionId : undefined;
+    return resumeStringField(resume, "claude_code", "sessionId");
 }
 class ClaudeInstance {
     kind = "claude_code";
@@ -323,7 +328,7 @@ class ClaudeInstance {
     #context;
     #status;
     #queryFn;
-    #sessions = new Set();
+    #sessions = new SessionResourceRegistry();
     constructor(input) {
         this.#config = input.config;
         this.#context = input.context;
@@ -334,19 +339,17 @@ class ClaudeInstance {
         return this.#status;
     }
     async startSession(options) {
+        this.#sessions.assertOpen();
         const session = new ClaudeSession({
             config: this.#config,
             context: this.#context,
             options,
             queryFn: this.#queryFn
         });
-        this.#sessions.add(session);
-        return session;
+        return this.#sessions.manage(session);
     }
     async dispose() {
-        for (const session of this.#sessions)
-            await session.stop();
-        this.#sessions.clear();
+        await this.#sessions.dispose();
     }
 }
 /** Probe the claude CLI: version via `claude --version`, auth from credential env. */

package/dist/index.js

@@ -1,4 +1,4 @@
-import { trimTrailingSlashes } from "@velum-labs/routekit-runtime";
+import { gatewayOrigin } from "@velum-labs/routekit-runtime/network";
 import { claudeDriverConfigSchema, createClaudeDriver } from "./driver.js";
 import { launchClaude } from "./launch.js";
 const driver = createClaudeDriver();
@@ -12,7 +12,7 @@ export const claudeTool = {
     installHint: "install Claude Code: https://docs.anthropic.com/en/docs/claude-code/overview",
     authSummary: "Claude Code uses the gateway's Anthropic-compatible surface.",
     setupSnippet: ({ gatewayUrl, model = "gateway-model" }) => [
-        `ANTHROPIC_BASE_URL=${trimTrailingSlashes(gatewayUrl)}`,
+        `ANTHROPIC_BASE_URL=${gatewayOrigin(gatewayUrl)}`,
         "ANTHROPIC_AUTH_TOKEN=routekit",
         `ANTHROPIC_MODEL=${model}`
     ].join("\n"),

package/dist/install-codec.d.ts

@@ -0,0 +1,58 @@
+export type ClaudeSettings = Record<string, unknown> & {
+    env?: Record<string, unknown>;
+};
+export type FileSnapshot = {
+    content: string | null;
+    mode: number | null;
+    hash: string | null;
+};
+export type InstalledManifest = {
+    version: 2;
+    state: "installed";
+    ownerId: string;
+    original: FileSnapshot;
+    exactRestoreEligible: boolean;
+    installedContentHash: string;
+    managedEnvValues: Record<string, string>;
+    /** `availableModels` entries contributed by RouteKit, never user entries. */
+    managedPickerModels?: string[];
+    /** True only when RouteKit created the `availableModels` array itself. */
+    managedAvailableModels?: true;
+    /** True only when RouteKit created this top-level policy setting. */
+    managedEnforceAvailableModels?: true;
+    /** Exact top-level apiKeyHelper string contributed by RouteKit. */
+    managedApiKeyHelper?: string;
+};
+export type InstallPendingManifest = {
+    version: 2;
+    state: "install-pending";
+    ownerId: string;
+    beforeSettings: FileSnapshot;
+    beforeManifest: InstalledManifest | null;
+    targetSettings: FileSnapshot;
+    targetManifest: InstalledManifest;
+};
+export type UninstallPendingManifest = {
+    version: 2;
+    state: "uninstall-pending";
+    ownerId: string;
+    beforeSettings: FileSnapshot;
+    targetSettings: FileSnapshot;
+};
+export type ClaudeInstallManifest = InstalledManifest | InstallPendingManifest | UninstallPendingManifest;
+export declare const MANAGED_ENV_KEYS: readonly ["ANTHROPIC_BASE_URL", "CLAUDE_CODE_ALWAYS_ENABLE_EFFORT"];
+export declare function hash(content: string): string;
+export declare function serialize(value: unknown): string;
+export declare function snapshot(content: string | null, mode: number | null): FileSnapshot;
+export declare function parseSettings(content: string, configPath: string): ClaudeSettings;
+export declare function unsupportedManifest(manifestPath: string): Error;
+export declare function parseManifest(content: string, manifestPath: string): ClaudeInstallManifest;
+export declare function managedEnv(input: {
+    gatewayUrl: string;
+}): Record<string, string>;
+export declare function pickerModels(input: {
+    models: readonly string[];
+}): string[];
+export declare function availableModels(settings: ClaudeSettings, configPath: string): string[] | undefined;
+export declare function enforceAvailableModels(settings: ClaudeSettings, configPath: string): boolean | undefined;
+export declare function removableManagedKeys(env: Record<string, unknown>, managedEnvValues: Record<string, string | string[]>, configPath: string): string[];

package/dist/install-codec.js

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+import { gatewayOrigin } from "@velum-labs/routekit-runtime/network";
+export const MANAGED_ENV_KEYS = ["ANTHROPIC_BASE_URL", "CLAUDE_CODE_ALWAYS_ENABLE_EFFORT"];
+const RETIRED_MANAGED_ENV_KEYS = [
+    "ANTHROPIC_AUTH_TOKEN",
+    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"
+];
+const CLAUDE_PICKER_PREFIX = "anthropic.routekit.";
+export function hash(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+export function serialize(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+export function snapshot(content, mode) {
+    return {
+        content,
+        mode,
+        hash: content === null ? null : hash(content)
+    };
+}
+export function parseSettings(content, configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message.split("\n")[0] : String(error);
+        throw new Error(`your Claude settings (${configPath}) are not valid JSON (${detail})`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`your Claude settings (${configPath}) must contain a JSON object`);
+    }
+    const settings = parsed;
+    if (settings.env !== undefined &&
+        (typeof settings.env !== "object" || settings.env === null || Array.isArray(settings.env))) {
+        throw new Error(`the "env" field in your Claude settings (${configPath}) must be an object`);
+    }
+    return settings;
+}
+export function unsupportedManifest(manifestPath) {
+    return new Error(`RouteKit's Claude ownership metadata (${manifestPath}) has an unsupported format`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSnapshot(value) {
+    if (!isRecord(value))
+        return false;
+    const validMode = value.mode === null ||
+        (typeof value.mode === "number" &&
+            Number.isInteger(value.mode) &&
+            value.mode >= 0 &&
+            value.mode <= 0o777);
+    return ((typeof value.content === "string" || value.content === null) &&
+        validMode &&
+        (value.content !== null || value.mode === null) &&
+        (typeof value.hash === "string" || value.hash === null) &&
+        value.hash === (value.content === null ? null : hash(value.content)));
+}
+function isStringRecord(value) {
+    return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isInstalledManifest(value) {
+    return (isRecord(value) &&
+        value.version === 2 &&
+        value.state === "installed" &&
+        typeof value.ownerId === "string" &&
+        isSnapshot(value.original) &&
+        typeof value.exactRestoreEligible === "boolean" &&
+        typeof value.installedContentHash === "string" &&
+        isStringRecord(value.managedEnvValues) &&
+        (value.managedPickerModels === undefined || isStringArray(value.managedPickerModels)) &&
+        (value.managedAvailableModels === undefined || value.managedAvailableModels === true) &&
+        (value.managedEnforceAvailableModels === undefined ||
+            value.managedEnforceAvailableModels === true) &&
+        (value.managedApiKeyHelper === undefined || typeof value.managedApiKeyHelper === "string"));
+}
+export function parseManifest(content, manifestPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new Error(`RouteKit's Claude ownership metadata (${manifestPath}) is invalid; ` +
+            "move it aside and restore settings.json before retrying");
+    }
+    if (isInstalledManifest(parsed))
+        return parsed;
+    if (isRecord(parsed) &&
+        parsed.version === 2 &&
+        parsed.state === "install-pending" &&
+        typeof parsed.ownerId === "string" &&
+        isSnapshot(parsed.beforeSettings) &&
+        (parsed.beforeManifest === null || isInstalledManifest(parsed.beforeManifest)) &&
+        isSnapshot(parsed.targetSettings) &&
+        isInstalledManifest(parsed.targetManifest)) {
+        const pending = parsed;
+        if (pending.targetManifest.ownerId !== pending.ownerId ||
+            pending.targetManifest.installedContentHash !== pending.targetSettings.hash ||
+            (pending.beforeManifest !== null && pending.beforeManifest.ownerId !== pending.ownerId)) {
+            throw unsupportedManifest(manifestPath);
+        }
+        return pending;
+    }
+    if (isRecord(parsed) &&
+        parsed.version === 2 &&
+        parsed.state === "uninstall-pending" &&
+        typeof parsed.ownerId === "string" &&
+        isSnapshot(parsed.beforeSettings) &&
+        isSnapshot(parsed.targetSettings)) {
+        return parsed;
+    }
+    throw unsupportedManifest(manifestPath);
+}
+export function managedEnv(input) {
+    return {
+        ANTHROPIC_BASE_URL: gatewayOrigin(input.gatewayUrl),
+        CLAUDE_CODE_ALWAYS_ENABLE_EFFORT: "1"
+    };
+}
+export function pickerModels(input) {
+    const models = new Set();
+    for (const model of input.models) {
+        if (typeof model !== "string" || model.length === 0) {
+            throw new Error("RouteKit's Claude picker catalog contains an invalid model id");
+        }
+        models.add(`${CLAUDE_PICKER_PREFIX}${model}`);
+    }
+    return [...models];
+}
+export function availableModels(settings, configPath) {
+    if (settings.availableModels === undefined)
+        return undefined;
+    if (!isStringArray(settings.availableModels)) {
+        throw new Error(`the "availableModels" field in your Claude settings (${configPath}) must be an array of strings`);
+    }
+    return [...settings.availableModels];
+}
+export function enforceAvailableModels(settings, configPath) {
+    if (settings.enforceAvailableModels === undefined)
+        return undefined;
+    if (typeof settings.enforceAvailableModels !== "boolean") {
+        throw new Error(`the "enforceAvailableModels" field in your Claude settings (${configPath}) must be a boolean`);
+    }
+    return settings.enforceAvailableModels;
+}
+export function removableManagedKeys(env, managedEnvValues, configPath) {
+    const removable = [];
+    for (const [key, expected] of Object.entries(managedEnvValues)) {
+        const accepted = Array.isArray(expected) ? expected : [expected];
+        if (accepted.includes(String(env[key]))) {
+            removable.push(key);
+            continue;
+        }
+        if (RETIRED_MANAGED_ENV_KEYS.includes(key))
+            continue;
+        throw new Error(`your Claude settings changed RouteKit-managed env.${key} in ${configPath}; ` +
+            `remove or restore that value before rerunning the install command`);
+    }
+    return removable;
+}

package/dist/install.js

@@ -1,17 +1,10 @@
 import { chmodSync, lstatSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { SUBSCRIPTIONS } from "@velum-labs/routekit-registry";
-import { acquireLifecycleLock, trimTrailingSlashes, writeFileAtomic } from "@velum-labs/routekit-runtime";
-const MANAGED_ENV_KEYS = [
-    "ANTHROPIC_BASE_URL",
-    "CLAUDE_CODE_ALWAYS_ENABLE_EFFORT"
-];
-const RETIRED_MANAGED_ENV_KEYS = [
-    "ANTHROPIC_AUTH_TOKEN",
-    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"
-];
+import { acquireLifecycleLock } from "@velum-labs/routekit-runtime/service";
+import { writeFileAtomic } from "@velum-labs/routekit-runtime/filesystem";
+import { availableModels, enforceAvailableModels, MANAGED_ENV_KEYS, managedEnv, parseManifest, parseSettings, pickerModels, removableManagedKeys, serialize, snapshot, unsupportedManifest } from "./install-codec.js";
 function reached(boundary) {
     // Deliberately not part of the package API: tests install a same-process
     // throw hook to model termination immediately after an atomic boundary.
@@ -48,158 +41,6 @@ function paths(input) {
         lockPath: join(configDirectory, ".routekit-claude-integration.lock")
     };
 }
-function hash(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-function parseSettings(content, configPath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message.split("\n")[0] : String(error);
-        throw new Error(`your Claude settings (${configPath}) are not valid JSON (${detail})`);
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new Error(`your Claude settings (${configPath}) must contain a JSON object`);
-    }
-    const settings = parsed;
-    if (settings.env !== undefined &&
-        (typeof settings.env !== "object" || settings.env === null || Array.isArray(settings.env))) {
-        throw new Error(`the "env" field in your Claude settings (${configPath}) must be an object`);
-    }
-    return settings;
-}
-function unsupportedManifest(manifestPath) {
-    return new Error(`RouteKit's Claude ownership metadata (${manifestPath}) has an unsupported format`);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isSnapshot(value) {
-    if (!isRecord(value))
-        return false;
-    const validMode = value.mode === null ||
-        (typeof value.mode === "number" &&
-            Number.isInteger(value.mode) &&
-            value.mode >= 0 &&
-            value.mode <= 0o777);
-    return ((typeof value.content === "string" || value.content === null) &&
-        validMode &&
-        (value.content !== null || value.mode === null) &&
-        (typeof value.hash === "string" || value.hash === null) &&
-        value.hash === (value.content === null ? null : hash(value.content)));
-}
-function isStringRecord(value) {
-    return (isRecord(value) &&
-        Object.values(value).every((entry) => typeof entry === "string"));
-}
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-function isInstalledManifest(value) {
-    return (isRecord(value) &&
-        value.version === 2 &&
-        value.state === "installed" &&
-        typeof value.ownerId === "string" &&
-        isSnapshot(value.original) &&
-        typeof value.exactRestoreEligible === "boolean" &&
-        typeof value.installedContentHash === "string" &&
-        isStringRecord(value.managedEnvValues) &&
-        (value.managedPickerModels === undefined || isStringArray(value.managedPickerModels)) &&
-        (value.managedAvailableModels === undefined || value.managedAvailableModels === true) &&
-        (value.managedEnforceAvailableModels === undefined ||
-            value.managedEnforceAvailableModels === true) &&
-        (value.managedApiKeyHelper === undefined || typeof value.managedApiKeyHelper === "string"));
-}
-function parseManifest(content, manifestPath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(content);
-    }
-    catch {
-        throw new Error(`RouteKit's Claude ownership metadata (${manifestPath}) is invalid; ` +
-            "move it aside and restore settings.json before retrying");
-    }
-    if (isRecord(parsed) &&
-        parsed.version === 1 &&
-        typeof parsed.ownerId === "string" &&
-        (typeof parsed.originalContent === "string" || parsed.originalContent === null) &&
-        typeof parsed.exactRestoreEligible === "boolean" &&
-        Array.isArray(parsed.installedContentHashes) &&
-        parsed.installedContentHashes.every((entry) => typeof entry === "string") &&
-        isRecord(parsed.managedEnvValues) &&
-        Object.values(parsed.managedEnvValues).every((entry) => Array.isArray(entry) &&
-            entry.every((candidate) => typeof candidate === "string"))) {
-        return parsed;
-    }
-    if (isInstalledManifest(parsed))
-        return parsed;
-    if (isRecord(parsed) &&
-        parsed.version === 2 &&
-        parsed.state === "install-pending" &&
-        typeof parsed.ownerId === "string" &&
-        isSnapshot(parsed.beforeSettings) &&
-        (parsed.beforeManifest === null ||
-            isInstalledManifest(parsed.beforeManifest)) &&
-        isSnapshot(parsed.targetSettings) &&
-        isInstalledManifest(parsed.targetManifest)) {
-        const pending = parsed;
-        if (pending.targetManifest.ownerId !== pending.ownerId ||
-            pending.targetManifest.installedContentHash !==
-                pending.targetSettings.hash ||
-            (pending.beforeManifest !== null &&
-                pending.beforeManifest.ownerId !== pending.ownerId)) {
-            throw unsupportedManifest(manifestPath);
-        }
-        return pending;
-    }
-    if (isRecord(parsed) &&
-        parsed.version === 2 &&
-        parsed.state === "uninstall-pending" &&
-        typeof parsed.ownerId === "string" &&
-        isSnapshot(parsed.beforeSettings) &&
-        isSnapshot(parsed.targetSettings)) {
-        return parsed;
-    }
-    throw unsupportedManifest(manifestPath);
-}
-function serialize(value) {
-    return `${JSON.stringify(value, null, 2)}\n`;
-}
-function managedEnv(input) {
-    return {
-        ANTHROPIC_BASE_URL: trimTrailingSlashes(input.gatewayUrl),
-        CLAUDE_CODE_ALWAYS_ENABLE_EFFORT: "1"
-    };
-}
-const CLAUDE_PICKER_PREFIX = "anthropic.routekit.";
-function pickerModels(input) {
-    const models = new Set();
-    for (const model of input.models) {
-        if (typeof model !== "string" || model.length === 0) {
-            throw new Error("RouteKit's Claude picker catalog contains an invalid model id");
-        }
-        models.add(`${CLAUDE_PICKER_PREFIX}${model}`);
-    }
-    return [...models];
-}
-function availableModels(settings, configPath) {
-    if (settings.availableModels === undefined)
-        return undefined;
-    if (!isStringArray(settings.availableModels)) {
-        throw new Error(`the "availableModels" field in your Claude settings (${configPath}) must be an array of strings`);
-    }
-    return [...settings.availableModels];
-}
-function enforceAvailableModels(settings, configPath) {
-    if (settings.enforceAvailableModels === undefined)
-        return undefined;
-    if (typeof settings.enforceAvailableModels !== "boolean") {
-        throw new Error(`the "enforceAvailableModels" field in your Claude settings (${configPath}) must be a boolean`);
-    }
-    return settings.enforceAvailableModels;
-}
 function entryIfExists(path) {
     try {
         return lstatSync(path);
@@ -244,20 +85,8 @@ function readSnapshot(path, label) {
     assertRegularFileIfExists(path, label);
     const entry = entryIfExists(path);
     if (entry === undefined)
-        return { content: null, mode: null, hash: null };
-    const content = readFileSync(path, "utf8");
-    return {
-        content,
-        mode: entry.mode & 0o777,
-        hash: hash(content)
-    };
-}
-function snapshot(content, mode) {
-    return {
-        content,
-        mode,
-        hash: content === null ? null : hash(content)
-    };
+        return snapshot(null, null);
+    return snapshot(readFileSync(path, "utf8"), entry.mode & 0o777);
 }
 function writePrivateFile(path, content, label) {
     assertRegularFileIfExists(path, label);
@@ -322,21 +151,6 @@ function recoverPending(manifest, configPath, manifestPath) {
     assertRegularFileIfExists(manifestPath, "Claude ownership metadata");
     rmSync(manifestPath, { force: true });
 }
-function removableManagedKeys(env, managedEnvValues, configPath) {
-    const removable = [];
-    for (const [key, expected] of Object.entries(managedEnvValues)) {
-        const accepted = Array.isArray(expected) ? expected : [expected];
-        if (accepted.includes(String(env[key]))) {
-            removable.push(key);
-            continue;
-        }
-        if (RETIRED_MANAGED_ENV_KEYS.includes(key))
-            continue;
-        throw new Error(`your Claude settings changed RouteKit-managed env.${key} in ${configPath}; ` +
-            `remove or restore that value before rerunning the install command`);
-    }
-    return removable;
-}
 const CLAUDE_LOCK_TIMEOUT_MS = 5_000;
 async function withConfigLock(resolved, operation) {
     ensureConfigDirectory(resolved.configDirectory);
@@ -355,93 +169,24 @@ async function withConfigLock(resolved, operation) {
         lock.release();
     }
 }
-function migrateLegacyManifest(manifest, current, configPath, manifestPath) {
-    const settings = parseSettings(current.content ?? "{}\n", configPath);
-    const env = { ...(settings.env ?? {}) };
-    const hasNoManagedValues = Object.keys(manifest.managedEnvValues).every((key) => env[key] === undefined);
-    if (current.content === manifest.originalContent &&
-        hasNoManagedValues) {
-        assertRegularFileIfExists(manifestPath, "Claude ownership metadata");
-        rmSync(manifestPath, { force: true });
-        return undefined;
-    }
-    const currentHash = current.hash;
-    if (currentHash === null) {
-        throw new Error(`RouteKit's legacy Claude ownership metadata (${manifestPath}) cannot ` +
-            "match missing settings; refusing to overwrite them");
-    }
-    let recognizedContent = manifest.installedContentHashes.includes(currentHash);
-    if (!recognizedContent) {
-        for (const key of RETIRED_MANAGED_ENV_KEYS) {
-            const accepted = manifest.managedEnvValues[key];
-            const value = env[key];
-            if (accepted === undefined || accepted.includes(String(value)))
-                continue;
-            for (const candidate of accepted) {
-                const candidateSettings = {
-                    ...settings,
-                    env: { ...env, [key]: candidate }
-                };
-                if (manifest.installedContentHashes.includes(hash(serialize(candidateSettings)))) {
-                    recognizedContent = true;
-                    break;
-                }
-            }
-        }
-    }
-    if (!recognizedContent) {
-        throw new Error(`RouteKit's legacy Claude ownership metadata (${manifestPath}) does not ` +
-            "match the current settings; refusing to overwrite them");
-    }
-    const selectedValues = {};
-    for (const [key, accepted] of Object.entries(manifest.managedEnvValues)) {
-        const value = env[key];
-        if (value === undefined || !accepted.includes(String(value))) {
-            if (RETIRED_MANAGED_ENV_KEYS.includes(key))
-                continue;
-            throw new Error(`RouteKit's legacy Claude ownership metadata (${manifestPath}) cannot ` +
-                `safely identify the current env.${key} value; refusing to overwrite settings`);
-        }
-        selectedValues[key] = String(value);
-    }
-    const migrated = {
-        version: 2,
-        state: "installed",
-        ownerId: manifest.ownerId,
-        original: snapshot(manifest.originalContent, null),
-        exactRestoreEligible: manifest.exactRestoreEligible &&
-            manifest.installedContentHashes.includes(currentHash),
-        installedContentHash: currentHash,
-        managedEnvValues: selectedValues
-    };
-    writeManifest(manifestPath, migrated);
-    return migrated;
-}
 export async function installClaudeIntegration(input) {
     const resolved = paths({
         ownerId: input.owner.id,
-        ...(input.claudeConfigDir !== undefined
-            ? { claudeConfigDir: input.claudeConfigDir }
-            : {})
+        ...(input.claudeConfigDir !== undefined ? { claudeConfigDir: input.claudeConfigDir } : {})
     });
     return await withConfigLock(resolved, () => {
         const { configPath, manifestPath } = resolved;
         let manifest = currentManifest(manifestPath);
-        if (manifest !== undefined &&
-            manifest.ownerId !== input.owner.id) {
+        if (manifest !== undefined && manifest.ownerId !== input.owner.id) {
             throw new Error(`Claude ownership metadata in ${manifestPath} belongs to another integration`);
         }
-        if (manifest?.version === 2 &&
-            manifest.state !== "installed") {
+        if (manifest?.version === 2 && manifest.state !== "installed") {
             recoverPending(manifest, configPath, manifestPath);
             manifest = currentManifest(manifestPath);
         }
         const beforeSettings = readSnapshot(configPath, "Claude settings");
         let previousManifest;
-        if (manifest?.version === 1) {
-            previousManifest = migrateLegacyManifest(manifest, beforeSettings, configPath, manifestPath);
-        }
-        else if (manifest?.state === "installed") {
+        if (manifest?.state === "installed") {
             previousManifest = manifest;
         }
         else if (manifest !== undefined) {
@@ -450,14 +195,12 @@ export async function installClaudeIntegration(input) {
         const settings = parseSettings(beforeSettings.content ?? "{}\n", configPath);
         const env = { ...(settings.env ?? {}) };
         const nextManaged = managedEnv(input);
-        if (settings.apiKeyHelper !== undefined &&
-            typeof settings.apiKeyHelper !== "string") {
+        if (settings.apiKeyHelper !== undefined && typeof settings.apiKeyHelper !== "string") {
             throw new Error(`the "apiKeyHelper" field in your Claude settings (${configPath}) must be a string`);
         }
         const currentApiKeyHelper = settings.apiKeyHelper;
         const previousApiKeyHelper = previousManifest?.managedApiKeyHelper;
-        if (previousApiKeyHelper !== undefined &&
-            currentApiKeyHelper !== previousApiKeyHelper) {
+        if (previousApiKeyHelper !== undefined && currentApiKeyHelper !== previousApiKeyHelper) {
             throw new Error(`your Claude settings changed RouteKit-managed apiKeyHelper in ${configPath}; ` +
                 "restore that value before rerunning the install command");
         }
@@ -508,12 +251,8 @@ export async function installClaudeIntegration(input) {
             ...settings,
             env,
             availableModels: nextPickerModels,
-            ...(input.apiKeyHelper !== undefined
-                ? { apiKeyHelper: input.apiKeyHelper }
-                : {}),
-            ...(nextManagedEnforceAvailableModels === true
-                ? { enforceAvailableModels: true }
-                : {})
+            ...(input.apiKeyHelper !== undefined ? { apiKeyHelper: input.apiKeyHelper } : {}),
+            ...(nextManagedEnforceAvailableModels === true ? { enforceAvailableModels: true } : {})
         };
         if (input.apiKeyHelper === undefined && previousApiKeyHelper !== undefined) {
             delete nextSettings.apiKeyHelper;
@@ -539,9 +278,7 @@ export async function installClaudeIntegration(input) {
             ...(nextManagedEnforceAvailableModels === true
                 ? { managedEnforceAvailableModels: true }
                 : {}),
-            ...(input.apiKeyHelper !== undefined
-                ? { managedApiKeyHelper: input.apiKeyHelper }
-                : {})
+            ...(input.apiKeyHelper !== undefined ? { managedApiKeyHelper: input.apiKeyHelper } : {})
         };
         const pendingManifest = {
             version: 2,
@@ -559,8 +296,7 @@ export async function installClaudeIntegration(input) {
         applySnapshot(configPath, targetSettings, "Claude settings");
         reached("install-settings");
         const pending = currentManifest(manifestPath);
-        if (pending?.version !== 2 ||
-            pending.state !== "install-pending") {
+        if (pending?.version !== 2 || pending.state !== "install-pending") {
             throw new Error(`Claude ownership metadata changed unexpectedly during install (${manifestPath})`);
         }
         writeManifest(manifestPath, targetManifest);
@@ -599,10 +335,7 @@ export async function uninstallClaudeIntegration(input) {
         }
         const beforeSettings = readSnapshot(configPath, "Claude settings");
         let installed;
-        if (manifest.version === 1) {
-            installed = migrateLegacyManifest(manifest, beforeSettings, configPath, manifestPath);
-        }
-        else if (manifest.state === "installed") {
+        if (manifest.state === "installed") {
             installed = manifest;
         }
         else {
@@ -611,8 +344,7 @@ export async function uninstallClaudeIntegration(input) {
         if (installed === undefined)
             return { configPath, removed: false };
         let targetSettings;
-        if (installed.exactRestoreEligible &&
-            beforeSettings.hash === installed.installedContentHash) {
+        if (installed.exactRestoreEligible && beforeSettings.hash === installed.installedContentHash) {
             targetSettings = installed.original;
         }
         else if (beforeSettings.content !== null) {
@@ -665,8 +397,7 @@ export async function uninstallClaudeIntegration(input) {
         applySnapshot(configPath, targetSettings, "Claude settings");
         reached("uninstall-settings");
         const pending = currentManifest(manifestPath);
-        if (pending?.version !== 2 ||
-            pending.state !== "uninstall-pending") {
+        if (pending?.version !== 2 || pending.state !== "uninstall-pending") {
             throw new Error(`Claude ownership metadata changed unexpectedly during uninstall (${manifestPath})`);
         }
         rmSync(manifestPath, { force: true });

package/dist/launch.js

@@ -1,7 +1,9 @@
-import { spawnTool } from "@velum-labs/routekit-runtime";
+import { hasFlag } from "@velum-labs/routekit-runtime/args";
+import { gatewayOrigin } from "@velum-labs/routekit-runtime/network";
+import { spawnTool } from "@velum-labs/routekit-runtime/process";
 export function claudeEnv(gatewayUrl, authToken) {
     return {
-        ANTHROPIC_BASE_URL: gatewayUrl,
+        ANTHROPIC_BASE_URL: gatewayOrigin(gatewayUrl),
         ANTHROPIC_AUTH_TOKEN: authToken ?? "routekit",
         CLAUDE_CODE_ALWAYS_ENABLE_EFFORT: "1",
         ...(process.env.CLAUDE_CONFIG_DIR !== undefined
@@ -23,25 +25,16 @@ export function claudeAgentsJson(profiles) {
         }
     ])));
 }
-function hasAgentsArg(args) {
-    return args.some((arg) => arg === "--agents" || arg.startsWith("--agents="));
-}
-function hasModelArg(args) {
-    return args.some((arg) => arg === "--model" || arg.startsWith("--model="));
-}
-function hasEffortArg(args) {
-    return args.some((arg) => arg === "--effort" || arg.startsWith("--effort="));
-}
 export function claudeLaunchArgs(ctx) {
     const args = [...ctx.spec.args];
-    if (!hasModelArg(args)) {
+    if (!hasFlag(args, "--model")) {
         args.unshift("--model", claudeModelId(ctx.spec.defaultModel));
-        if (ctx.spec.reasoning?.mode === "effort" && !hasEffortArg(args)) {
+        if (ctx.spec.reasoning?.mode === "effort" && !hasFlag(args, "--effort")) {
             args.unshift("--effort", ctx.spec.reasoning.effort);
         }
     }
     const profiles = ctx.spec.agentProfiles ?? [];
-    if (profiles.length > 0 && !hasAgentsArg(args)) {
+    if (profiles.length > 0 && !hasFlag(args, "--agents")) {
         args.push("--agents", claudeAgentsJson(profiles));
     }
     return args;

package/dist/test/driver.test.js

@@ -115,6 +115,35 @@ test("claude driver forwards opaque effort through SDK options", async () => {
         await instance.dispose();
     }
 });
+test("claude driver releases the turn when query setup throws", async () => {
+    const delegate = scriptedQuery("claude-setup-retry");
+    let attempts = 0;
+    const setupDriver = createClaudeDriver({
+        queryFn: (input) => {
+            attempts += 1;
+            if (attempts === 1)
+                throw new Error("query setup failed");
+            return delegate(input);
+        }
+    });
+    const instance = await setupDriver.createInstance(setupDriver.configSchema.parse({ command: "claude" }));
+    try {
+        const session = await instance.startSession({ cwd: process.cwd() });
+        await assert.rejects(async () => {
+            for await (const _event of session.sendTurn({ prompt: "first" })) {
+                // Drain.
+            }
+        }, /query setup failed/);
+        const events = [];
+        for await (const event of session.sendTurn({ prompt: "second" })) {
+            events.push(event);
+        }
+        assert.equal(events.find((event) => event.type === "turn.completed")?.endReason, "completed");
+    }
+    finally {
+        await instance.dispose();
+    }
+});
 test("claude driver auto-approves tools under the automation policy", async () => {
     const instance = await driver.createInstance(driver.configSchema.parse({ command: "claude" }));
     try {

package/dist/test/install.test.js

@@ -489,195 +489,6 @@ test("updating a v2 install preserves a user-edited token", async () => {
         rmSync(configDirectory, { recursive: true, force: true });
     }
 });
-test("updating a legacy install removes its formerly managed ANTHROPIC_MODEL", async () => {
-    const configDirectory = mkdtempSync(join(tmpdir(), "routekit-claude-legacy-model-"));
-    const configPath = join(configDirectory, "settings.json");
-    const manifestPath = join(configDirectory, `.${OWNER.id}-integration.json`);
-    const original = '{"theme":"light"}\n';
-    const installed = `${JSON.stringify({
-        theme: "light",
-        env: {
-            ANTHROPIC_BASE_URL: "http://127.0.0.1:7000",
-            ANTHROPIC_AUTH_TOKEN: "routekit",
-            CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
-            ANTHROPIC_MODEL: "claude-code/legacy"
-        }
-    }, null, 2)}\n`;
-    writeFileSync(configPath, installed);
-    writeFileSync(manifestPath, `${JSON.stringify({
-        version: 1,
-        ownerId: OWNER.id,
-        originalContent: original,
-        exactRestoreEligible: true,
-        installedContentHashes: [
-            createHash("sha256").update(installed).digest("hex")
-        ],
-        managedEnvValues: {
-            ANTHROPIC_BASE_URL: ["http://127.0.0.1:7000"],
-            ANTHROPIC_AUTH_TOKEN: ["routekit"],
-            CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: ["1"],
-            ANTHROPIC_MODEL: ["claude-code/legacy"]
-        }
-    }, null, 2)}\n`);
-    try {
-        await install(configDirectory, "http://127.0.0.1:7001");
-        const settings = JSON.parse(readFileSync(configPath, "utf8"));
-        assert.equal("ANTHROPIC_MODEL" in settings.env, false);
-        await uninstallClaudeIntegration({
-            ownerId: OWNER.id,
-            claudeConfigDir: configDirectory
-        });
-        assert.equal(readFileSync(configPath, "utf8"), original);
-    }
-    finally {
-        rmSync(configDirectory, { recursive: true, force: true });
-    }
-});
-function writeInterruptedLegacyUpdate(configDirectory, phase) {
-    const configPath = join(configDirectory, "settings.json");
-    const manifestPath = join(configDirectory, `.${OWNER.id}-integration.json`);
-    const original = '{"theme":"light"}\n';
-    const content = (baseUrl, authToken, model) => `${JSON.stringify({
-        theme: "light",
-        env: {
-            ANTHROPIC_BASE_URL: baseUrl,
-            ANTHROPIC_AUTH_TOKEN: authToken,
-            CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
-            ANTHROPIC_MODEL: model
-        }
-    }, null, 2)}\n`;
-    const before = content("http://127.0.0.1:7000", "before-token", "claude-code/before");
-    const after = content("http://127.0.0.1:7001", "after-token", "claude-code/after");
-    writeFileSync(configPath, phase === "before-settings" ? before : after);
-    writeFileSync(manifestPath, `${JSON.stringify({
-        version: 1,
-        ownerId: OWNER.id,
-        originalContent: original,
-        exactRestoreEligible: true,
-        installedContentHashes: [before, after].map((value) => createHash("sha256").update(value).digest("hex")),
-        managedEnvValues: {
-            ANTHROPIC_BASE_URL: [
-                "http://127.0.0.1:7000",
-                "http://127.0.0.1:7001"
-            ],
-            ANTHROPIC_AUTH_TOKEN: ["before-token", "after-token"],
-            CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: ["1"],
-            ANTHROPIC_MODEL: [
-                "claude-code/before",
-                "claude-code/after"
-            ]
-        }
-    }, null, 2)}\n`);
-    return { configPath, manifestPath, original };
-}
-test("install migrates interrupted v1 updates before and after settings", async () => {
-    for (const phase of ["before-settings", "after-settings"]) {
-        const configDirectory = mkdtempSync(join(tmpdir(), `routekit-claude-v1-install-${phase}-`));
-        const { configPath, manifestPath, original } = writeInterruptedLegacyUpdate(configDirectory, phase);
-        try {
-            const result = await install(configDirectory, "http://127.0.0.1:7002", "final-token");
-            assert.equal(result.action, "updated");
-            const settings = JSON.parse(readFileSync(configPath, "utf8"));
-            assert.equal(settings.env.ANTHROPIC_BASE_URL, "http://127.0.0.1:7002");
-            assert.equal("ANTHROPIC_AUTH_TOKEN" in settings.env, false);
-            assert.equal("ANTHROPIC_MODEL" in settings.env, false);
-            const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-            assert.deepEqual({ version: manifest.version, state: manifest.state }, { version: 2, state: "installed" });
-            assert.equal("ANTHROPIC_AUTH_TOKEN" in manifest.managedEnvValues, false);
-            assert.equal(readFileSync(manifestPath, "utf8").includes("final-token"), false);
-            assert.equal(readFileSync(manifestPath, "utf8").includes("before-token"), false);
-            assert.equal(readFileSync(manifestPath, "utf8").includes("after-token"), false);
-            await uninstallClaudeIntegration({
-                ownerId: OWNER.id,
-                claudeConfigDir: configDirectory
-            });
-            assert.equal(readFileSync(configPath, "utf8"), original);
-        }
-        finally {
-            rmSync(configDirectory, { recursive: true, force: true });
-        }
-    }
-});
-test("uninstall migrates interrupted v1 updates before and after settings", async () => {
-    for (const phase of ["before-settings", "after-settings"]) {
-        const configDirectory = mkdtempSync(join(tmpdir(), `routekit-claude-v1-uninstall-${phase}-`));
-        const { configPath, manifestPath, original } = writeInterruptedLegacyUpdate(configDirectory, phase);
-        try {
-            assert.equal((await uninstallClaudeIntegration({
-                ownerId: OWNER.id,
-                claudeConfigDir: configDirectory
-            })).removed, true);
-            assert.equal(readFileSync(configPath, "utf8"), original);
-            assert.equal(existsSync(manifestPath), false);
-        }
-        finally {
-            rmSync(configDirectory, { recursive: true, force: true });
-        }
-    }
-});
-test("legacy migration refuses unrecognized settings without overwriting", async () => {
-    const configDirectory = mkdtempSync(join(tmpdir(), "routekit-claude-v1-external-"));
-    const { configPath, manifestPath } = writeInterruptedLegacyUpdate(configDirectory, "after-settings");
-    const external = '{"external":true}\n';
-    writeFileSync(configPath, external);
-    const manifest = readFileSync(manifestPath, "utf8");
-    try {
-        await assert.rejects(install(configDirectory), /does not match the current settings/);
-        assert.equal(readFileSync(configPath, "utf8"), external);
-        assert.equal(readFileSync(manifestPath, "utf8"), manifest);
-    }
-    finally {
-        rmSync(configDirectory, { recursive: true, force: true });
-    }
-});
-test("untouched original settings discard a stale pre-install v1 manifest", async () => {
-    const configDirectory = mkdtempSync(join(tmpdir(), "routekit-claude-v1-original-"));
-    const configPath = join(configDirectory, "settings.json");
-    const manifestPath = join(configDirectory, `.${OWNER.id}-integration.json`);
-    const original = '{"theme":"light"}\n';
-    const target = `${JSON.stringify({
-        theme: "light",
-        env: {
-            ANTHROPIC_BASE_URL: "http://127.0.0.1:7000",
-            ANTHROPIC_AUTH_TOKEN: "routekit",
-            CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
-        }
-    }, null, 2)}\n`;
-    const writeStaleManifest = () => {
-        writeFileSync(manifestPath, `${JSON.stringify({
-            version: 1,
-            ownerId: OWNER.id,
-            originalContent: original,
-            exactRestoreEligible: true,
-            installedContentHashes: [original, target].map((value) => createHash("sha256").update(value).digest("hex")),
-            managedEnvValues: {
-                ANTHROPIC_BASE_URL: ["http://127.0.0.1:7000"],
-                ANTHROPIC_AUTH_TOKEN: ["routekit"],
-                CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: ["1"]
-            }
-        }, null, 2)}\n`);
-    };
-    writeFileSync(configPath, original);
-    try {
-        writeStaleManifest();
-        assert.equal((await uninstallClaudeIntegration({
-            ownerId: OWNER.id,
-            claudeConfigDir: configDirectory
-        })).removed, false);
-        assert.equal(existsSync(manifestPath), false);
-        assert.equal(readFileSync(configPath, "utf8"), original);
-        writeStaleManifest();
-        assert.equal((await install(configDirectory)).action, "installed");
-        await uninstallClaudeIntegration({
-            ownerId: OWNER.id,
-            claudeConfigDir: configDirectory
-        });
-        assert.equal(readFileSync(configPath, "utf8"), original);
-    }
-    finally {
-        rmSync(configDirectory, { recursive: true, force: true });
-    }
-});
 test("new config directories are 0700 and exact restore preserves settings mode", async () => {
     const root = mkdtempSync(join(tmpdir(), "routekit-claude-mode-"));
     const createdDirectory = join(root, "nested", "claude");

package/dist/test/launch.test.js

@@ -78,6 +78,9 @@ test("Claude launcher forwards an explicit isolated config directory", () => {
             process.env.CLAUDE_CONFIG_DIR = previous;
     }
 });
+test("Claude launcher strips an OpenAI API suffix from the gateway origin", () => {
+    assert.equal(claudeEnv("http://127.0.0.1:8080/v1/").ANTHROPIC_BASE_URL, "http://127.0.0.1:8080");
+});
 test("claudeLaunchArgs adds profiles unless the user supplied agents", () => {
     const args = claudeLaunchArgs(context(["--verbose"]));
     assert.deepEqual(args.slice(0, 4), [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-tool-claude",
   "private": false,
-  "version": "0.18.6",
+  "version": "1.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -14,6 +14,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./driver": {
+      "types": "./dist/driver.d.ts",
+      "default": "./dist/driver.js"
+    },
+    "./install": {
+      "types": "./dist/install.d.ts",
+      "default": "./dist/install.js"
+    },
+    "./launch": {
+      "types": "./dist/launch.d.ts",
+      "default": "./dist/launch.js"
     }
   },
   "files": [
@@ -30,11 +42,11 @@
     "@anthropic-ai/sdk": "0.115.0",
     "@modelcontextprotocol/sdk": "1.29.0",
     "zod": "4.4.3",
-    "@velum-labs/routekit-contracts": "0.18.6",
-    "@velum-labs/routekit-harness-core": "0.18.6",
-    "@velum-labs/routekit-registry": "0.18.6",
-    "@velum-labs/routekit-runtime": "0.18.6",
-    "@velum-labs/routekit-tools": "0.18.6"
+    "@velum-labs/routekit-contracts": "1.0.0",
+    "@velum-labs/routekit-harness-core": "1.0.0",
+    "@velum-labs/routekit-runtime": "1.0.0",
+    "@velum-labs/routekit-tools": "1.0.0",
+    "@velum-labs/routekit-registry": "1.0.0"
   },
   "keywords": [
     "llm",
@@ -44,7 +56,7 @@
     "adapter"
   ],
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsc -p tsconfig.json",
     "clean": "tsc -b --clean",
     "test": "node --test \"dist/test/*.test.js\""
   }