@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/providers/claude/hooks/event-translator.js

@@ -0,0 +1,151 @@
+import { mapClaudeRunningToolCall, mapClaudeCompletedToolCall } from "../tool-call-mapper.js";
+/**
+ * Translate a daemon-internal HookEvent into zero-or-more AgentStreamEvent(s)
+ * that the pump can emit verbatim via its existing emitStreamEvent path.
+ *
+ * Returns:
+ *   - `[]` when the event was handled entirely via side-effect callbacks
+ *     (session-start, permission registered without an emit, etc.)
+ *   - One or more AgentStreamEvent shapes that the pump should emit
+ *   - `null` if the event could not be translated (caller may log/skip)
+ *
+ * The translator is pure (modulo `ctx.*` callbacks): no global state, no I/O.
+ * Tool-call mapping is delegated to `tool-call-mapper.ts` so the shapes stay
+ * identical across SDK and PTY transports.
+ */
+export function translateHookEvent(event, ctx) {
+    switch (event.kind) {
+        case "pre-tool":
+            return translatePreTool(event, ctx);
+        case "post-tool":
+            return translatePostTool(event, ctx);
+        case "permission":
+            return translatePermission(event, ctx);
+        case "session-start":
+            ctx.onSessionStart?.(event);
+            return [];
+        case "session-end":
+            return translateSessionEnd(event, ctx);
+        case "status-line":
+            return translateStatusLine(event, ctx);
+        case "assistant_message_delta":
+            return translateAssistantDelta(event, ctx);
+        case "usage_update":
+            return translateUsageUpdate(event, ctx);
+        default: {
+            // Exhaustiveness guard suppressed: the HookEvent union has grown new
+            // variants (PreCompactionHookEvent, etc.) without translator coverage.
+            // Falling through to null keeps runtime safe; tracked in docs/tech-debt.md.
+            return null;
+        }
+    }
+}
+function deriveCallId(event) {
+    // The hook payload does not (today) carry tool_use_id. Derive a stable
+    // synthetic id from agent_id + tool_name + the JSON-serialized input so the
+    // running event and the matching completed event collapse to the same row.
+    // This is a best-effort scheme — when the real hook bridge starts forwarding
+    // tool_use_id (Phase 1+), prefer that field over this fallback.
+    const hashSource = `${event.agent_id}:${event.tool_name}:${safeStringify(event.tool_input)}`;
+    return synthHash(hashSource);
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function synthHash(input) {
+    // FNV-1a 32-bit — small, deterministic, no crypto dep needed for a
+    // tool-call correlation id.
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `hook-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function translatePreTool(event, ctx) {
+    const item = mapClaudeRunningToolCall({
+        callId: deriveCallId(event),
+        name: event.tool_name,
+        input: event.tool_input,
+    });
+    if (!item)
+        return [];
+    return [{ type: "timeline", item, provider: ctx.provider, turnId: ctx.turnId }];
+}
+function translatePostTool(event, ctx) {
+    const item = mapClaudeCompletedToolCall({
+        callId: deriveCallId(event),
+        name: event.tool_name,
+        input: event.tool_input,
+        output: event.tool_response,
+    });
+    if (!item)
+        return [];
+    return [{ type: "timeline", item, provider: ctx.provider, turnId: ctx.turnId }];
+}
+function translatePermission(event, ctx) {
+    const request = ctx.registerPermissionRequest(event);
+    if (!request)
+        return [];
+    return [
+        {
+            type: "permission_requested",
+            provider: ctx.provider,
+            request,
+            turnId: ctx.turnId,
+        },
+    ];
+}
+function translateSessionEnd(_event, ctx) {
+    // session-end currently carries no usage payload in our HookEvent schema.
+    // Emit a turn_completed marker without usage so the client UI can settle
+    // the active turn. Usage updates flow through usage_update events from the
+    // TranscriptTailer.
+    return [{ type: "turn_completed", provider: ctx.provider, turnId: ctx.turnId }];
+}
+function translateStatusLine(event, ctx) {
+    // status-line provides a free-form statusText — Claude Code typically formats
+    // it as e.g. "ctx: 12%  in 1.2k out 0.4k". We do not parse the string here;
+    // the contextWindowUsedTokens signal is sourced from usage_update events
+    // (transcript tailer). status-line currently surfaces only as a heartbeat —
+    // we emit an empty usage_updated so the UI knows the agent is alive.
+    void event;
+    const usage = {};
+    return [{ type: "usage_updated", provider: ctx.provider, usage, turnId: ctx.turnId }];
+}
+function translateAssistantDelta(event, ctx) {
+    const text = event.delta.text;
+    if (!text)
+        return [];
+    // The pump appends assistant text deltas to the current turn's
+    // assistant_message timeline item. We surface them as a `timeline` event
+    // with a partial assistant_message item so the existing rendering path on
+    // the client treats them identically to SDK-path deltas.
+    return [
+        {
+            type: "timeline",
+            provider: ctx.provider,
+            turnId: ctx.turnId,
+            item: {
+                type: "assistant_message",
+                text,
+            },
+        },
+    ];
+}
+function translateUsageUpdate(event, ctx) {
+    const u = event.usage;
+    const usage = {
+        inputTokens: u.input_tokens,
+        outputTokens: u.output_tokens,
+        cachedInputTokens: (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) || undefined,
+        totalCostUsd: u.total_cost_usd,
+    };
+    return [{ type: "usage_updated", provider: ctx.provider, usage, turnId: ctx.turnId }];
+}
+//# sourceMappingURL=event-translator.js.map

package/dist/server/server/agent/providers/claude/image-compression.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "pino";
+export type CompressibleImageMimeType = "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+export interface CompressedImage {
+    data: string;
+    mediaType: "image/jpeg";
+    originalBytes: number;
+    compressedBytes: number;
+}
+export declare function compressImageForApi(base64Data: string, sourceMimeType: CompressibleImageMimeType, logger?: Logger): Promise<CompressedImage>;
+//# sourceMappingURL=image-compression.d.ts.map

package/dist/server/server/agent/providers/claude/image-compression.js

@@ -0,0 +1,32 @@
+import sharp from "sharp";
+const MAX_WIDTH_PX = 1280;
+const JPEG_QUALITY = 60;
+export async function compressImageForApi(base64Data, sourceMimeType, logger) {
+    const input = Buffer.from(base64Data, "base64");
+    const originalBytes = input.byteLength;
+    try {
+        const output = await sharp(input, { animated: sourceMimeType === "image/gif" })
+            .resize({ width: MAX_WIDTH_PX, withoutEnlargement: true })
+            .jpeg({ quality: JPEG_QUALITY })
+            .toBuffer();
+        return {
+            data: output.toString("base64"),
+            mediaType: "image/jpeg",
+            originalBytes,
+            compressedBytes: output.byteLength,
+        };
+    }
+    catch (error) {
+        logger?.warn({ err: error, sourceMimeType, originalBytes }, "Image compression failed; passing image through unchanged");
+        if (sourceMimeType === "image/jpeg") {
+            return {
+                data: base64Data,
+                mediaType: "image/jpeg",
+                originalBytes,
+                compressedBytes: originalBytes,
+            };
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=image-compression.js.map

package/dist/server/server/agent/providers/claude/model-manifest.d.ts

@@ -0,0 +1,104 @@
+import type { AgentModelDefinition } from "../../agent-sdk-types.js";
+export declare const CLAUDE_ULTRACODE_THINKING_OPTION_ID = "ultracode";
+export declare const CLAUDE_MODEL_MANIFEST: readonly [{
+    readonly id: "claude-fable-5";
+    readonly label: "Fable 5";
+    readonly description: "Fable 5 · Most powerful model";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+}, {
+    readonly id: "claude-opus-5[1m]";
+    readonly label: "Opus 5 1M";
+    readonly description: "Opus 5 with 1M context window";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-5";
+    readonly label: "Opus 5";
+    readonly description: "Opus 5 · Latest release, best for complex agentic coding";
+    readonly isDefault: true;
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-4-8[1m]";
+    readonly label: "Opus 4.8 1M";
+    readonly description: "Opus 4.8 with 1M context window";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-4-8";
+    readonly label: "Opus 4.8";
+    readonly description: "Opus 4.8 · Previous release";
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-sonnet-5";
+    readonly label: "Sonnet 5";
+    readonly description: "Sonnet 5 · Best for everyday tasks";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+}, {
+    readonly id: "claude-opus-4-7[1m]";
+    readonly label: "Opus 4.7 1M";
+    readonly description: "Opus 4.7 with 1M context window";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-4-7";
+    readonly label: "Opus 4.7";
+    readonly description: "Opus 4.7 · Previous release";
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-4-6[1m]";
+    readonly label: "Opus 4.6 1M";
+    readonly description: "Opus 4.6 with 1M context window";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-4-6";
+    readonly label: "Opus 4.6";
+    readonly description: "Opus 4.6 · Most capable for complex work";
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "max"];
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-sonnet-4-6[1m]";
+    readonly label: "Sonnet 4.6 1M";
+    readonly description: "Sonnet 4.6 with 1M context window";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "max"];
+}, {
+    readonly id: "claude-sonnet-4-6";
+    readonly label: "Sonnet 4.6";
+    readonly description: "Sonnet 4.6 · Best for everyday tasks";
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "max"];
+}, {
+    readonly id: "claude-haiku-4-5";
+    readonly label: "Haiku 4.5";
+    readonly description: "Haiku 4.5 · Fastest for quick answers";
+    readonly contextWindowMaxTokens: 200000;
+}];
+export declare function getClaudeManifestModels(): AgentModelDefinition[];
+export declare function isClaudeManifestModelId(modelId: string): boolean;
+export declare function claudeManifestModelSupportsFastMode(modelId: string | null | undefined): boolean;
+/**
+ * Normalize first-party Claude model IDs for manifest capability checks. Provider-prefixed
+ * runtime IDs intentionally use normalizeClaudeRuntimeModelId instead.
+ */
+export declare function normalizeClaudeManifestModelId(value: string | null | undefined): string | null;
+/**
+ * Normalize a Claude Code runtime/config model string to a known manifest ID.
+ * Runtime metadata may include provider prefixes such as Bedrock model IDs; feature
+ * gates should use normalizeClaudeManifestModelId instead.
+ */
+export declare function normalizeClaudeRuntimeModelId(value: string | null | undefined): string | null;
+//# sourceMappingURL=model-manifest.d.ts.map

package/dist/server/server/agent/providers/claude/model-manifest.js

@@ -0,0 +1,221 @@
+const CLAUDE_EFFORT_LEVELS = {
+    standard: ["low", "medium", "high", "max"],
+    xhigh: ["low", "medium", "high", "xhigh", "max"],
+};
+const CLAUDE_EFFORT_LABELS = {
+    low: "Low",
+    medium: "Medium",
+    high: "High",
+    xhigh: "Extra High",
+    max: "Max",
+};
+export const CLAUDE_ULTRACODE_THINKING_OPTION_ID = "ultracode";
+export const CLAUDE_MODEL_MANIFEST = [
+    {
+        id: "claude-fable-5",
+        label: "Fable 5",
+        description: "Fable 5 · Most powerful model",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+    },
+    {
+        id: "claude-opus-5[1m]",
+        label: "Opus 5 1M",
+        description: "Opus 5 with 1M context window",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 · Latest release, best for complex agentic coding",
+        isDefault: true,
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-8[1m]",
+        label: "Opus 4.8 1M",
+        description: "Opus 4.8 with 1M context window",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-8",
+        label: "Opus 4.8",
+        description: "Opus 4.8 · Previous release",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-sonnet-5",
+        label: "Sonnet 5",
+        description: "Sonnet 5 · Best for everyday tasks",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+    },
+    {
+        id: "claude-opus-4-7[1m]",
+        label: "Opus 4.7 1M",
+        description: "Opus 4.7 with 1M context window",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 · Previous release",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-6[1m]",
+        label: "Opus 4.6 1M",
+        description: "Opus 4.6 with 1M context window",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.standard,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-6",
+        label: "Opus 4.6",
+        description: "Opus 4.6 · Most capable for complex work",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.standard,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-sonnet-4-6[1m]",
+        label: "Sonnet 4.6 1M",
+        description: "Sonnet 4.6 with 1M context window",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.standard,
+    },
+    {
+        id: "claude-sonnet-4-6",
+        label: "Sonnet 4.6",
+        description: "Sonnet 4.6 · Best for everyday tasks",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.standard,
+    },
+    {
+        id: "claude-haiku-4-5",
+        label: "Haiku 4.5",
+        description: "Haiku 4.5 · Fastest for quick answers",
+        contextWindowMaxTokens: 200000,
+    },
+];
+function buildThinkingOptions(effortLevels) {
+    if (!effortLevels) {
+        return undefined;
+    }
+    const options = effortLevels.map((id) => ({
+        id,
+        label: CLAUDE_EFFORT_LABELS[id],
+    }));
+    if (effortLevels.includes("xhigh")) {
+        options.push({ id: CLAUDE_ULTRACODE_THINKING_OPTION_ID, label: "Ultra Code" });
+    }
+    return options;
+}
+export function getClaudeManifestModels() {
+    return CLAUDE_MODEL_MANIFEST.map((model) => {
+        const thinkingOptions = buildThinkingOptions("effortLevels" in model ? model.effortLevels : undefined);
+        return {
+            provider: "claude",
+            id: model.id,
+            label: model.label,
+            description: model.description,
+            ...("isDefault" in model && model.isDefault ? { isDefault: true } : {}),
+            ...(model.contextWindowMaxTokens !== undefined
+                ? { contextWindowMaxTokens: model.contextWindowMaxTokens }
+                : {}),
+            ...(thinkingOptions ? { thinkingOptions } : {}),
+        };
+    });
+}
+export function isClaudeManifestModelId(modelId) {
+    return CLAUDE_MODEL_MANIFEST.some((model) => model.id === modelId);
+}
+export function claudeManifestModelSupportsFastMode(modelId) {
+    const normalizedModelId = normalizeClaudeManifestModelId(modelId);
+    if (!normalizedModelId) {
+        return false;
+    }
+    return CLAUDE_MODEL_MANIFEST.some((model) => model.id === normalizedModelId &&
+        "supportsFastMode" in model &&
+        model.supportsFastMode === true);
+}
+/**
+ * Normalize first-party Claude model IDs for manifest capability checks. Provider-prefixed
+ * runtime IDs intentionally use normalizeClaudeRuntimeModelId instead.
+ */
+export function normalizeClaudeManifestModelId(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (!trimmed) {
+        return null;
+    }
+    if (isClaudeManifestModelId(trimmed)) {
+        return trimmed;
+    }
+    const singleSegmentMatch = trimmed.match(/^(?:claude[-_ ])?(fable|opus|sonnet|haiku)[-_ ]+(\d+)(\[1m\])?(?:[-_ ]+\d{8})?$/i);
+    if (singleSegmentMatch) {
+        return normalizeSingleSegmentClaudeModelId(singleSegmentMatch[1], singleSegmentMatch[2], trimmed.toLowerCase().includes("[1m]"));
+    }
+    const runtimeMatch = trimmed.match(/^(?:claude[-_ ])?(opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(\[1m\])?(?:[-_ ]+\d{8})?$/i);
+    if (!runtimeMatch) {
+        return null;
+    }
+    return normalizeMajorMinorClaudeModelId(runtimeMatch[1], runtimeMatch[2], runtimeMatch[3], Boolean(runtimeMatch[4]));
+}
+/**
+ * Normalize a Claude Code runtime/config model string to a known manifest ID.
+ * Runtime metadata may include provider prefixes such as Bedrock model IDs; feature
+ * gates should use normalizeClaudeManifestModelId instead.
+ */
+export function normalizeClaudeRuntimeModelId(value) {
+    const normalizedManifestModelId = normalizeClaudeManifestModelId(value);
+    if (normalizedManifestModelId) {
+        return normalizedManifestModelId;
+    }
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (!trimmed) {
+        return null;
+    }
+    const singleSegmentMatch = trimmed.match(/claude[-_ ](fable|opus|sonnet|haiku)[-_ ]+(\d+)(\[1m\])?/i);
+    if (singleSegmentMatch) {
+        const normalizedModelId = normalizeSingleSegmentClaudeModelId(singleSegmentMatch[1], singleSegmentMatch[2], Boolean(singleSegmentMatch[3]));
+        if (normalizedModelId) {
+            return normalizedModelId;
+        }
+    }
+    const runtimeMatch = trimmed.match(/claude[-_ ](opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(\[1m\])?/i);
+    if (!runtimeMatch) {
+        return null;
+    }
+    return normalizeMajorMinorClaudeModelId(runtimeMatch[1], runtimeMatch[2], runtimeMatch[3], Boolean(runtimeMatch[4]));
+}
+function normalizeSingleSegmentClaudeModelId(familyValue, major, hasOneMillionContext) {
+    const family = familyValue.toLowerCase();
+    const suffix = hasOneMillionContext ? "[1m]" : "";
+    const candidates = [`claude-${family}-${major}${suffix}`, `claude-${family}-${major}`];
+    for (const candidate of candidates) {
+        if (isClaudeManifestModelId(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function normalizeMajorMinorClaudeModelId(familyValue, major, minor, hasOneMillionContext) {
+    const family = familyValue.toLowerCase();
+    const suffix = hasOneMillionContext ? "[1m]" : "";
+    const candidate = `claude-${family}-${major}-${minor}${suffix}`;
+    return isClaudeManifestModelId(candidate) ? candidate : null;
+}
+//# sourceMappingURL=model-manifest.js.map

package/dist/server/server/agent/providers/claude/models.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "pino";
+import type { AgentModelDefinition } from "../../agent-sdk-types.js";
+export declare function getClaudeModels(): AgentModelDefinition[];
+export declare function findClaudeModel(modelId: string | null | undefined): AgentModelDefinition | undefined;
+export declare function getClaudeModelsWithSettings(logger: Logger, configDir?: string): Promise<AgentModelDefinition[]>;
+/**
+ * Normalize a runtime model string (from SDK init message) to a known model ID.
+ * Handles the `[1m]` suffix that the SDK appends for 1M context sessions.
+ */
+export declare function normalizeClaudeRuntimeModelId(value: string | null | undefined): string | null;
+//# sourceMappingURL=models.d.ts.map

package/dist/server/server/agent/providers/claude/models.js

@@ -0,0 +1,97 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getClaudeManifestModels, normalizeClaudeRuntimeModelId as normalizeClaudeManifestRuntimeModelId, } from "./model-manifest.js";
+const CLAUDE_SETTINGS_MODEL_ENV_KEYS = [
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+];
+export function getClaudeModels() {
+    return getClaudeManifestModels();
+}
+export function findClaudeModel(modelId) {
+    const normalizedModelId = normalizeClaudeRuntimeModelId(modelId);
+    if (!normalizedModelId) {
+        return undefined;
+    }
+    return getClaudeModels().find((model) => model.id === normalizedModelId);
+}
+export async function getClaudeModelsWithSettings(logger, configDir) {
+    const hardcodedModels = getClaudeModels();
+    const settingsModels = await readClaudeSettingsModels(logger, configDir);
+    if (settingsModels.length === 0) {
+        return hardcodedModels;
+    }
+    const seenModelIds = new Set(hardcodedModels.map((model) => model.id));
+    const models = [...hardcodedModels];
+    for (const model of settingsModels) {
+        if (seenModelIds.has(model.id)) {
+            continue;
+        }
+        seenModelIds.add(model.id);
+        models.push(model);
+    }
+    return models;
+}
+async function readClaudeSettingsModels(logger, configDir) {
+    const settingsPath = path.join(resolveClaudeConfigDir(configDir), "settings.json");
+    let parsed;
+    try {
+        const rawSettings = await fs.readFile(settingsPath, "utf8");
+        parsed = JSON.parse(rawSettings);
+    }
+    catch (error) {
+        logger.debug({ err: error, settingsPath }, "Failed to read Claude settings models");
+        return [];
+    }
+    if (!isRecord(parsed)) {
+        logger.debug({ settingsPath }, "Claude settings.json is not an object");
+        return [];
+    }
+    const models = [];
+    addSettingsModel(models, parsed.model, "model");
+    const env = parsed.env;
+    if (env === undefined) {
+        return models;
+    }
+    if (!isRecord(env)) {
+        logger.debug({ settingsPath }, "Claude settings.json env is not an object");
+        return models;
+    }
+    for (const envKey of CLAUDE_SETTINGS_MODEL_ENV_KEYS) {
+        addSettingsModel(models, env[envKey], `env.${envKey}`);
+    }
+    return models;
+}
+function resolveClaudeConfigDir(configDir) {
+    return configDir ?? process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+}
+function addSettingsModel(models, value, settingsKey) {
+    if (typeof value !== "string") {
+        return;
+    }
+    const id = value.trim();
+    if (id.length === 0 || models.some((model) => model.id === id)) {
+        return;
+    }
+    models.push({
+        provider: "claude",
+        id,
+        label: id,
+        description: `From Claude settings.json ${settingsKey}`,
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Normalize a runtime model string (from SDK init message) to a known model ID.
+ * Handles the `[1m]` suffix that the SDK appends for 1M context sessions.
+ */
+export function normalizeClaudeRuntimeModelId(value) {
+    return normalizeClaudeManifestRuntimeModelId(value);
+}
+//# sourceMappingURL=models.js.map

package/dist/server/server/agent/providers/claude/partial-json.d.ts

@@ -0,0 +1,5 @@
+export declare function parsePartialJsonObject(input: string): {
+    value: Record<string, unknown>;
+    complete: boolean;
+} | null;
+//# sourceMappingURL=partial-json.d.ts.map