@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/claude/feature-definitions.d.ts

@@ -0,0 +1,8 @@
+import type { AgentFeature, AgentFeatureToggle } from "../../agent-sdk-types.js";
+export declare const CLAUDE_FAST_MODE_FEATURE: Omit<AgentFeatureToggle, "value">;
+export declare function claudeModelSupportsFastMode(modelId: string | null | undefined): boolean;
+export declare function buildClaudeFeatures(input: {
+    modelId: string | null | undefined;
+    fastModeEnabled: boolean;
+}): AgentFeature[];
+//# sourceMappingURL=feature-definitions.d.ts.map

package/dist/server/server/agent/providers/claude/feature-definitions.js

@@ -0,0 +1,24 @@
+import { claudeManifestModelSupportsFastMode } from "./model-manifest.js";
+export const CLAUDE_FAST_MODE_FEATURE = {
+    type: "toggle",
+    id: "fast_mode",
+    label: "Fast",
+    description: "Lower latency Opus responses at higher token cost",
+    tooltip: "Toggle fast mode",
+    icon: "zap",
+};
+export function claudeModelSupportsFastMode(modelId) {
+    return claudeManifestModelSupportsFastMode(modelId);
+}
+export function buildClaudeFeatures(input) {
+    if (!claudeModelSupportsFastMode(input.modelId)) {
+        return [];
+    }
+    return [
+        {
+            ...CLAUDE_FAST_MODE_FEATURE,
+            value: input.fastModeEnabled,
+        },
+    ];
+}
+//# sourceMappingURL=feature-definitions.js.map

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

@@ -0,0 +1,12 @@
+import type { ClaudeOptions } from "./query.js";
+type ClaudeHooks = NonNullable<ClaudeOptions["hooks"]>;
+/**
+ * Combine Paseo's observation hooks with any the user configured, per event.
+ *
+ * Neither side wins: Claude Code runs every matcher registered for an event, so appending keeps
+ * a user's hooks working while Paseo keeps observing. Assigning either one would silently drop
+ * the other, and the failure would be invisible — effort would simply stop appearing.
+ */
+export declare function mergeClaudeHooks(own: ClaudeHooks, extra: unknown): ClaudeHooks;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1,20 @@
+/**
+ * Combine Paseo's observation hooks with any the user configured, per event.
+ *
+ * Neither side wins: Claude Code runs every matcher registered for an event, so appending keeps
+ * a user's hooks working while Paseo keeps observing. Assigning either one would silently drop
+ * the other, and the failure would be invisible — effort would simply stop appearing.
+ */
+export function mergeClaudeHooks(own, extra) {
+    if (!extra || typeof extra !== "object")
+        return own;
+    const merged = { ...own };
+    for (const [event, matchers] of Object.entries(extra)) {
+        if (!Array.isArray(matchers))
+            continue;
+        const key = event;
+        merged[key] = [...(merged[key] ?? []), ...matchers];
+    }
+    return merged;
+}
+//# sourceMappingURL=hooks.js.map

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

@@ -0,0 +1,147 @@
+import type { AgentModelDefinition, AgentSelectOption } from "../../agent-sdk-types.js";
+export declare const CLAUDE_DEFAULT_THINKING_OPTION_ID = "high";
+export declare const CLAUDE_DISABLED_THINKING_OPTION_ID = "off";
+export declare const CLAUDE_ULTRACODE_THINKING_OPTION_ID = "ultracode";
+export declare const CLAUDE_MODEL_MANIFEST: readonly [{
+    readonly id: "claude-opus-5";
+    readonly label: "Opus 5";
+    readonly description: "Opus 5 · Latest release";
+    readonly defaultPriority: 2;
+    readonly minimumClaudeCodeVersion: "2.1.219";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsThinkingDisabled: true;
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-5[1m]";
+    readonly label: "Opus 5 1M";
+    readonly description: "Opus 5 with 1M context window";
+    readonly minimumClaudeCodeVersion: "2.1.219";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsThinkingDisabled: true;
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-fable-5-1";
+    readonly label: "Fable 5.1";
+    readonly description: "Fable 5.1 · Most powerful model";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+}, {
+    readonly id: "claude-fable-5";
+    readonly aliases: readonly ["claude-fable-5[1m]"];
+    readonly label: "Fable 5";
+    readonly description: "Fable 5 · Previous release";
+    readonly minimumClaudeCodeVersion: "2.1.169";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+}, {
+    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 supportsThinkingDisabled: true;
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-opus-4-8";
+    readonly label: "Opus 4.8";
+    readonly description: "Opus 4.8 · Previous release";
+    readonly defaultPriority: 1;
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsThinkingDisabled: true;
+    readonly supportsFastMode: true;
+}, {
+    readonly id: "claude-sonnet-5";
+    readonly label: "Sonnet 5";
+    readonly description: "Sonnet 5 · Best for everyday tasks";
+    readonly contextWindowMaxTokens: 200000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsThinkingDisabled: true;
+}, {
+    readonly id: "claude-sonnet-5[1m]";
+    readonly label: "Sonnet 5 1M";
+    readonly description: "Sonnet 5 with 1M context window";
+    readonly contextWindowMaxTokens: 1000000;
+    readonly effortLevels: readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly supportsThinkingDisabled: true;
+}, {
+    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 supportsThinkingDisabled: true;
+    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 supportsThinkingDisabled: true;
+    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 supportsThinkingDisabled: true;
+    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 supportsThinkingDisabled: true;
+    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 supportsThinkingDisabled: true;
+}, {
+    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 supportsThinkingDisabled: true;
+}, {
+    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(claudeCodeVersion?: string): AgentModelDefinition[];
+export declare function compareVersions(left: string, right: string): number;
+export declare function parseClaudeCodeVersion(value: string): [number, number, number] | null;
+export interface ClaudeDisabledThinkingResolution {
+    supported: boolean;
+    fallbackThinkingOptionId: string | undefined;
+}
+/**
+ * Resolve the disabled-thinking capability from the curated manifest only. Runtime/provider
+ * model aliases intentionally do not inherit this capability.
+ */
+export declare function resolveClaudeDisabledThinkingForModel(modelId: string | null | undefined): ClaudeDisabledThinkingResolution;
+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;
+export declare function getClaudeCustomModelThinkingOptions(): AgentSelectOption[];
+//# sourceMappingURL=model-manifest.d.ts.map

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

@@ -0,0 +1,342 @@
+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_DEFAULT_THINKING_OPTION_ID = "high";
+export const CLAUDE_DISABLED_THINKING_OPTION_ID = "off";
+export const CLAUDE_ULTRACODE_THINKING_OPTION_ID = "ultracode";
+export const CLAUDE_MODEL_MANIFEST = [
+    {
+        id: "claude-opus-5",
+        label: "Opus 5",
+        description: "Opus 5 · Latest release",
+        defaultPriority: 2,
+        minimumClaudeCodeVersion: "2.1.219",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsThinkingDisabled: true,
+        supportsFastMode: true,
+    },
+    {
+        // The suffixed spelling selects the 1M-context runtime in Claude Code, so it stays a
+        // selectable entry of its own rather than a compatibility alias of the plain id.
+        id: "claude-opus-5[1m]",
+        label: "Opus 5 1M",
+        description: "Opus 5 with 1M context window",
+        minimumClaudeCodeVersion: "2.1.219",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsThinkingDisabled: true,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-fable-5-1",
+        label: "Fable 5.1",
+        description: "Fable 5.1 · Most powerful model",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+    },
+    {
+        id: "claude-fable-5",
+        // COMPAT(claudeFable5OneMillionId): added in v0.3.0, remove after 2027-02-06 once pre-v0.3.0 app preferences are outside support.
+        aliases: ["claude-fable-5[1m]"],
+        label: "Fable 5",
+        description: "Fable 5 · Previous release",
+        minimumClaudeCodeVersion: "2.1.169",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+    },
+    {
+        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,
+        supportsThinkingDisabled: true,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-8",
+        label: "Opus 4.8",
+        description: "Opus 4.8 · Previous release",
+        defaultPriority: 1,
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsThinkingDisabled: true,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-sonnet-5",
+        label: "Sonnet 5",
+        description: "Sonnet 5 · Best for everyday tasks",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsThinkingDisabled: true,
+    },
+    {
+        id: "claude-sonnet-5[1m]",
+        label: "Sonnet 5 1M",
+        description: "Sonnet 5 with 1M context window",
+        contextWindowMaxTokens: 1000000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsThinkingDisabled: true,
+    },
+    {
+        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,
+        supportsThinkingDisabled: true,
+        supportsFastMode: true,
+    },
+    {
+        id: "claude-opus-4-7",
+        label: "Opus 4.7",
+        description: "Opus 4.7 · Previous release",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.xhigh,
+        supportsThinkingDisabled: true,
+        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,
+        supportsThinkingDisabled: true,
+        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,
+        supportsThinkingDisabled: true,
+        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,
+        supportsThinkingDisabled: true,
+    },
+    {
+        id: "claude-sonnet-4-6",
+        label: "Sonnet 4.6",
+        description: "Sonnet 4.6 · Best for everyday tasks",
+        contextWindowMaxTokens: 200000,
+        effortLevels: CLAUDE_EFFORT_LEVELS.standard,
+        supportsThinkingDisabled: true,
+    },
+    {
+        id: "claude-haiku-4-5",
+        label: "Haiku 4.5",
+        description: "Haiku 4.5 · Fastest for quick answers",
+        contextWindowMaxTokens: 200000,
+    },
+];
+function buildThinkingOptions(effortLevels, supportsThinkingDisabled) {
+    if (!effortLevels) {
+        return undefined;
+    }
+    const options = [
+        ...(supportsThinkingDisabled ? [{ id: CLAUDE_DISABLED_THINKING_OPTION_ID, label: "Off" }] : []),
+        ...effortLevels.map((id) => ({
+            id,
+            label: CLAUDE_EFFORT_LABELS[id],
+            ...(id === CLAUDE_DEFAULT_THINKING_OPTION_ID ? { isDefault: true } : {}),
+        })),
+    ];
+    if (effortLevels.includes("xhigh")) {
+        options.push({ id: CLAUDE_ULTRACODE_THINKING_OPTION_ID, label: "Ultra Code" });
+    }
+    return options;
+}
+export function getClaudeManifestModels(claudeCodeVersion) {
+    const availableModels = CLAUDE_MODEL_MANIFEST.filter((model) => isModelAvailableInClaudeCode(model, claudeCodeVersion));
+    const defaultModel = availableModels.reduce((selected, candidate) => (candidate.defaultPriority ?? 0) > (selected?.defaultPriority ?? 0) ? candidate : selected, undefined);
+    const definitions = [];
+    for (const model of availableModels) {
+        const thinkingOptions = buildThinkingOptions(model.effortLevels, model.supportsThinkingDisabled === true);
+        const definition = {
+            provider: "claude",
+            id: model.id,
+            label: model.label,
+            description: model.description,
+        };
+        if ("aliases" in model && model.aliases) {
+            definition.aliases = [...model.aliases];
+        }
+        if (model === defaultModel) {
+            definition.isDefault = true;
+        }
+        if (model.contextWindowMaxTokens !== undefined) {
+            definition.contextWindowMaxTokens = model.contextWindowMaxTokens;
+        }
+        if (thinkingOptions) {
+            definition.thinkingOptions = thinkingOptions;
+            definition.defaultThinkingOptionId = CLAUDE_DEFAULT_THINKING_OPTION_ID;
+        }
+        definitions.push(definition);
+        if (!("aliases" in model) || !model.aliases) {
+            continue;
+        }
+        // COMPAT(claudeFable5LegacyCatalogEntry): added in v0.3.0, remove after 2027-02-06 once pre-v0.3.0 apps are outside support.
+        for (const alias of model.aliases) {
+            definitions.push({
+                ...definition,
+                id: alias,
+                aliases: undefined,
+                isDefault: undefined,
+                isSelectable: false,
+            });
+        }
+    }
+    return definitions;
+}
+function isModelAvailableInClaudeCode(model, claudeCodeVersion) {
+    if (!model.minimumClaudeCodeVersion || claudeCodeVersion === undefined) {
+        return true;
+    }
+    return compareVersions(claudeCodeVersion, model.minimumClaudeCodeVersion) >= 0;
+}
+export function compareVersions(left, right) {
+    const leftParts = parseClaudeCodeVersion(left);
+    const rightParts = parseClaudeCodeVersion(right);
+    if (!leftParts || !rightParts) {
+        return -1;
+    }
+    for (let index = 0; index < leftParts.length; index += 1) {
+        const difference = leftParts[index] - rightParts[index];
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return 0;
+}
+export function parseClaudeCodeVersion(value) {
+    const match = value.match(/\b(\d+)\.(\d+)\.(\d+)\s+\(Claude Code\)/i) ??
+        value.match(/\b(\d+)\.(\d+)\.(\d+)\b/);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+/**
+ * Resolve the disabled-thinking capability from the curated manifest only. Runtime/provider
+ * model aliases intentionally do not inherit this capability.
+ */
+export function resolveClaudeDisabledThinkingForModel(modelId) {
+    const normalizedModelId = normalizeClaudeManifestModelId(modelId);
+    const model = normalizedModelId
+        ? CLAUDE_MODEL_MANIFEST.find((candidate) => candidate.id === normalizedModelId)
+        : undefined;
+    return {
+        supported: !!model && "supportsThinkingDisabled" in model && model.supportsThinkingDisabled === true,
+        fallbackThinkingOptionId: model && "effortLevels" in model ? CLAUDE_DEFAULT_THINKING_OPTION_ID : undefined,
+    };
+}
+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})?(?:\[1m\])?$/i);
+    if (singleSegmentMatch) {
+        return normalizeSingleSegmentClaudeModelId(singleSegmentMatch[1], singleSegmentMatch[2], trimmed.toLowerCase().includes("[1m]"));
+    }
+    const runtimeMatch = trimmed.match(/^(?:claude[-_ ])?(fable|opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(?:\[1m\])?(?:[-_ ]+\d{8})?(?:\[1m\])?$/i);
+    if (!runtimeMatch) {
+        return null;
+    }
+    return normalizeMajorMinorClaudeModelId(runtimeMatch[1], runtimeMatch[2], runtimeMatch[3], trimmed.toLowerCase().includes("[1m]"));
+}
+/**
+ * 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], trimmed.toLowerCase().includes("[1m]"));
+        if (normalizedModelId) {
+            return normalizedModelId;
+        }
+    }
+    const runtimeMatch = trimmed.match(/claude[-_ ](fable|opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(\[1m\])?/i);
+    if (!runtimeMatch) {
+        return null;
+    }
+    return normalizeMajorMinorClaudeModelId(runtimeMatch[1], runtimeMatch[2], runtimeMatch[3], trimmed.toLowerCase().includes("[1m]"));
+}
+export function getClaudeCustomModelThinkingOptions() {
+    return CLAUDE_EFFORT_LEVELS.standard.map((id) => {
+        const option = { id, label: CLAUDE_EFFORT_LABELS[id] };
+        if (id === CLAUDE_DEFAULT_THINKING_OPTION_ID)
+            option.isDefault = true;
+        return option;
+    });
+}
+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 candidates = [
+        `claude-${family}-${major}-${minor}${suffix}`,
+        `claude-${family}-${major}-${minor}`,
+    ];
+    for (const candidate of candidates) {
+        if (isClaudeManifestModelId(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=model-manifest.js.map

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

@@ -0,0 +1,28 @@
+import type { Logger } from "pino";
+import type { AgentModelDefinition } from "../../agent-sdk-types.js";
+export declare function getClaudeModels(claudeCodeVersion?: string): AgentModelDefinition[];
+export declare function resolveConfiguredClaudeModel(model: AgentModelDefinition): AgentModelDefinition;
+export declare function findClaudeModel(modelId: string | null | undefined): AgentModelDefinition | undefined;
+export declare function getClaudeModelsWithSettings(logger: Logger, configDir?: string, claudeCodeVersion?: 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;
+/**
+ * Resolve a model id observed on a Claude assistant frame, for display.
+ *
+ * Prefers the manifest-normalized id so equivalent spellings collapse (a dated alias and a
+ * gateway prefix are the same model), but falls back to the raw string when the manifest does
+ * not know it. The fallback matters: Claude Code is an Anthropic-compatible client, so subagents
+ * routinely report models that are not Anthropic's — Z.AI GLM ids via `ANTHROPIC_BASE_URL`
+ * (docs/custom-providers.md) among them. Manifest-only resolution would blank the model for
+ * exactly those users.
+ *
+ * A `[1m]` suffix is preserved where it names its own manifest entry. Models such as Fable 5
+ * that only have a 1M entry normalize the retired suffixed spelling to the canonical ID.
+ *
+ * Returns null for placeholders and empty values, meaning "not observed".
+ */
+export declare function resolveObservedClaudeModelId(value: string | null | undefined): string | null;
+//# sourceMappingURL=models.d.ts.map