@jun133/kitty 0.0.13 → 0.0.15

package/dist/{chunk-3KMC6H5K.mjs → chunk-S4QTRPZ7.mjs}

@@ -1,1212 +1,237 @@
-// src/provider/capabilities.ts
-var DEFAULT_PROVIDER = "openai-compatible";
+// src/provider/catalog.ts
 var DEFAULT_REQUEST_TIMEOUT_MS = 10 * 60 * 1e3;
 var DEFAULT_DOCTOR_PROBE_TIMEOUT_MS = 1e4;
 var RELAY_REQUEST_TIMEOUT_MS = 15 * 60 * 1e3;
 var RELAY_DOCTOR_PROBE_TIMEOUT_MS = 45e3;
-function resolveProviderCapabilities(input) {
-  const provider = normalizeProviderName(input.provider);
-  const model = normalizeModelName(input.model);
-  if (provider === "deepseek" || model.startsWith("deepseek-")) {
-    return {
-      provider: "deepseek",
-      model,
-      wireApi: "chat.completions",
-      supportsReasoningContent: true,
-      defaultReasoningEnabled: true,
-      defaultReasoningEffort: "high",
-      requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
-      doctorProbeTimeoutMs: DEFAULT_DOCTOR_PROBE_TIMEOUT_MS
-    };
-  }
-  if (provider === "openai" || model === "gpt-5.4") {
-    return {
-      provider: "openai",
-      model,
-      wireApi: "responses",
-      supportsReasoningContent: false,
-      defaultReasoningEnabled: true,
-      defaultReasoningEffort: "xhigh",
-      requestTimeoutMs: RELAY_REQUEST_TIMEOUT_MS,
-      doctorProbeTimeoutMs: RELAY_DOCTOR_PROBE_TIMEOUT_MS
-    };
-  }
-  return {
-    provider,
-    model,
-    wireApi: "chat.completions",
-    supportsReasoningContent: false,
-    defaultReasoningEnabled: false,
+var PROVIDER_CATALOG = [
+  {
+    id: "deepseek",
+    label: "DeepSeek official",
+    apiKind: "deepseek-openai-compatible",
+    transport: "standard",
+    defaultBaseUrl: "https://api.deepseek.com",
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    doctorProbeTimeoutMs: DEFAULT_DOCTOR_PROBE_TIMEOUT_MS
+  },
+  {
+    id: "yls",
+    label: "YLS Codex",
+    apiKind: "openai-sdk",
+    transport: "relay",
+    defaultBaseUrl: "https://code.ylsagi.com/codex",
+    requestTimeoutMs: RELAY_REQUEST_TIMEOUT_MS,
+    doctorProbeTimeoutMs: RELAY_DOCTOR_PROBE_TIMEOUT_MS
+  },
+  {
+    id: "ttapi",
+    label: "TTAPI",
+    apiKind: "openai-sdk",
+    transport: "relay",
+    defaultBaseUrl: "https://w.ciykj.cn",
+    requestTimeoutMs: RELAY_REQUEST_TIMEOUT_MS,
+    doctorProbeTimeoutMs: RELAY_DOCTOR_PROBE_TIMEOUT_MS
+  },
+  {
+    id: "openai",
+    label: "OpenAI official",
+    apiKind: "openai-sdk",
+    transport: "standard",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    requestTimeoutMs: RELAY_REQUEST_TIMEOUT_MS,
+    doctorProbeTimeoutMs: RELAY_DOCTOR_PROBE_TIMEOUT_MS
+  },
+  {
+    id: "openai-compatible",
+    label: "OpenAI-compatible",
+    apiKind: "openai-compatible",
+    transport: "standard",
+    defaultBaseUrl: "",
     requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
     doctorProbeTimeoutMs: DEFAULT_DOCTOR_PROBE_TIMEOUT_MS
-  };
-}
-function normalizeProviderName(value) {
-  const normalized = String(value ?? "").trim().toLowerCase();
-  return normalized || DEFAULT_PROVIDER;
-}
-function normalizeModelName(value) {
-  return String(value ?? "").trim();
-}
-
-// src/utils/abort.ts
-function createAbortError(message = "Operation aborted") {
-  const error = new Error(message);
-  error.name = "AbortError";
-  error.code = "ABORT_ERR";
-  return error;
-}
-function isAbortError(error) {
-  if (!error) {
-    return false;
-  }
-  if (error instanceof Error) {
-    if (error.name === "AbortError") {
-      return true;
-    }
-    const code = String(error.code ?? "");
-    if (code === "ABORT_ERR" || code === "ERR_ABORTED" || code === "ABORTED") {
-      return true;
-    }
-    const message = error.message.toLowerCase();
-    if (message.includes("abort") || message.includes("aborted") || message.includes("cancelled") || message.includes("canceled")) {
-      return true;
-    }
-  }
-  if (typeof error === "object" && error && "cause" in error) {
-    return isAbortError(error.cause);
-  }
-  return false;
-}
-function throwIfAborted(signal, message) {
-  if (signal?.aborted) {
-    throw createAbortError(message ?? "Operation aborted");
-  }
-}
-function sleepWithSignal(ms, signal) {
-  if (!signal) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
-  }
-  if (signal.aborted) {
-    return Promise.reject(createAbortError("Sleep aborted"));
-  }
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", onAbort);
-      reject(createAbortError("Sleep aborted"));
-    };
-    signal.addEventListener("abort", onAbort);
-  });
-}
-
-// src/provider/apiRetry.ts
-var API_MAX_RETRIES = 3;
-var API_RETRY_BASE_DELAY_MS = 1200;
-async function withApiRetries(operation, abortSignal) {
-  let lastError;
-  for (let attempt = 1; attempt <= API_MAX_RETRIES; attempt += 1) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (isAbortError(error)) {
-        throw error;
-      }
-      lastError = error;
-      if (!isRetryableApiError(error) || attempt === API_MAX_RETRIES) {
-        break;
-      }
-      await sleepWithSignal(API_RETRY_BASE_DELAY_MS * attempt, abortSignal);
-    }
-  }
-  throw lastError;
-}
-function isRetryableApiError(error) {
-  const status = error.status;
-  if (typeof status === "number") {
-    return status === 408 || status === 409 || status === 429 || status >= 500;
-  }
-  const message = String(error.message ?? error).toLowerCase();
-  return message.includes("timeout") || message.includes("network") || message.includes("connection error") || message.includes("connection reset") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("connect timeout") || message.includes("temporarily") || message.includes("rate limit") || message.includes("overloaded");
-}
-
-// src/provider/usageNormalizer.ts
-function normalizeProviderUsage(usage) {
-  if (!usage || typeof usage !== "object") {
-    return void 0;
-  }
-  const record = usage;
-  const promptDetails = readObject(record.prompt_tokens_details);
-  const completionDetails = readObject(record.completion_tokens_details);
-  const outputDetails = readObject(record.output_tokens_details);
-  const cacheCreation = readObject(record.cache_creation);
-  const inputTokens = readUsageNumber(record.prompt_tokens ?? record.input_tokens);
-  const outputTokens = readUsageNumber(record.completion_tokens ?? record.output_tokens);
-  const totalTokens = readUsageNumber(record.total_tokens);
-  const reasoningTokens = readUsageNumber(
-    completionDetails?.reasoning_tokens ?? outputDetails?.reasoning_tokens
-  );
-  const openAiCachedTokens = readUsageNumber(promptDetails?.cached_tokens);
-  const deepSeekHitTokens = readUsageNumber(record.prompt_cache_hit_tokens);
-  const deepSeekMissTokens = readUsageNumber(record.prompt_cache_miss_tokens);
-  const anthropicCacheReadTokens = readUsageNumber(record.cache_read_input_tokens);
-  const anthropicCacheCreationTokens = readUsageNumber(record.cache_creation_input_tokens) ?? sumUsageNumbers([
-    cacheCreation?.ephemeral_1h_input_tokens,
-    cacheCreation?.ephemeral_5m_input_tokens
-  ]);
-  const geminiCachedTokens = readUsageNumber(record.cachedContentTokenCount ?? record.cached_content_token_count);
-  const cacheReadTokens = firstNumber(
-    anthropicCacheReadTokens,
-    openAiCachedTokens,
-    geminiCachedTokens
-  );
-  const cacheHitTokens = firstNumber(deepSeekHitTokens, cacheReadTokens);
-  const cacheMissTokens = deepSeekMissTokens;
-  const cacheCreationTokens = anthropicCacheCreationTokens;
-  const snapshot = {
-    inputTokens,
-    outputTokens,
-    totalTokens,
-    reasoningTokens,
-    cacheReadTokens,
-    cacheCreationTokens,
-    cacheHitTokens,
-    cacheMissTokens
-  };
-  const cacheHitRate = computeCacheHitRate(snapshot);
-  if (cacheHitRate !== void 0) {
-    snapshot.cacheHitRate = cacheHitRate;
-  }
-  return Object.values(snapshot).some((value) => typeof value === "number") ? snapshot : void 0;
-}
-function hasProviderUsageSnapshot(usage) {
-  return Boolean(usage && Object.values(usage).some((value) => typeof value === "number"));
-}
-function computeCacheHitRate(snapshot) {
-  if (typeof snapshot.cacheHitTokens === "number" && typeof snapshot.cacheMissTokens === "number") {
-    return ratio(snapshot.cacheHitTokens, snapshot.cacheHitTokens + snapshot.cacheMissTokens);
-  }
-  if (typeof snapshot.cacheReadTokens === "number") {
-    const denominator = (snapshot.inputTokens ?? 0) + snapshot.cacheReadTokens + (snapshot.cacheCreationTokens ?? 0);
-    return ratio(snapshot.cacheReadTokens, denominator);
-  }
-  return void 0;
-}
-function ratio(numerator, denominator) {
-  if (denominator <= 0) {
-    return void 0;
-  }
-  return Math.round(numerator / denominator * 1e4) / 1e4;
-}
-function readObject(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function firstNumber(...values) {
-  return values.find((value) => typeof value === "number");
-}
-function sumUsageNumbers(values) {
-  const numbers = values.map(readUsageNumber).filter((value) => typeof value === "number");
-  if (numbers.length === 0) {
-    return void 0;
   }
-  return numbers.reduce((total, value) => total + value, 0);
-}
-function readUsageNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
-}
-
-// src/observability/writer.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-
-// src/project/statePaths.ts
-import fs from "fs/promises";
-import path from "path";
-var PROJECT_STATE_DIR_NAME = ".kitty";
-var PROJECT_STATE_ENV_FILE_NAME = ".env";
-var PROJECT_STATE_ENV_EXAMPLE_FILE_NAME = ".env.example";
-var PROJECT_STATE_IGNORE_FILE_NAME = ".kittyignore";
-var PRESERVED_PROJECT_STATE_ENTRY_NAMES = [
-  PROJECT_STATE_ENV_FILE_NAME,
-  PROJECT_STATE_ENV_EXAMPLE_FILE_NAME
 ];
-function getProjectStatePaths(rootDir) {
-  const normalizedRoot = path.resolve(rootDir);
-  const kittyDir = path.join(normalizedRoot, PROJECT_STATE_DIR_NAME);
-  const extensionsDir = path.join(kittyDir, "extensions");
-  const memoryDir = path.join(kittyDir, "memory");
-  const observabilityDir = path.join(kittyDir, "observability");
-  return {
-    rootDir: normalizedRoot,
-    kittyDir,
-    cacheDir: path.join(kittyDir, "cache"),
-    sessionsDir: path.join(kittyDir, "sessions"),
-    changesDir: path.join(kittyDir, "changes"),
-    eventsDir: path.join(kittyDir, "events"),
-    extensionsDir,
-    memoryDir,
-    evidenceMemoryDir: path.join(memoryDir, "evidence"),
-    projectMemoryDir: path.join(memoryDir, "project"),
-    sessionMemoryDir: path.join(memoryDir, "sessions"),
-    userMemoryDir: path.join(memoryDir, "user"),
-    controlPlaneLedgerFile: path.join(kittyDir, "control-plane.sqlite"),
-    observabilityDir,
-    observabilityEventsDir: path.join(observabilityDir, "events"),
-    observabilityCrashesDir: path.join(observabilityDir, "crashes")
-  };
-}
-async function ensureProjectStateDirectories(rootDir) {
-  const paths = getProjectStatePaths(rootDir);
-  await fs.mkdir(paths.extensionsDir, { recursive: true });
-  await fs.mkdir(paths.cacheDir, { recursive: true });
-  await fs.mkdir(paths.sessionsDir, { recursive: true });
-  await fs.mkdir(paths.changesDir, { recursive: true });
-  await fs.mkdir(paths.eventsDir, { recursive: true });
-  await fs.mkdir(paths.evidenceMemoryDir, { recursive: true });
-  await fs.mkdir(paths.projectMemoryDir, { recursive: true });
-  await fs.mkdir(paths.sessionMemoryDir, { recursive: true });
-  await fs.mkdir(paths.userMemoryDir, { recursive: true });
-  await fs.mkdir(paths.observabilityEventsDir, { recursive: true });
-  await fs.mkdir(paths.observabilityCrashesDir, { recursive: true });
-  return paths;
-}
-
-// src/observability/schema.ts
-var OBSERVABILITY_VERSION = 1;
-function buildObservabilityEventRecord(input) {
-  return {
-    version: OBSERVABILITY_VERSION,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    event: normalizeText(input.event, "unknown"),
-    status: normalizeText(input.status, "unknown"),
-    host: normalizeOptionalText(input.host),
-    sessionId: normalizeOptionalText(input.sessionId),
-    executionId: normalizeOptionalText(input.executionId),
-    identityKind: normalizeOptionalText(input.identityKind),
-    identityName: normalizeOptionalText(input.identityName),
-    durationMs: normalizeOptionalNumber(input.durationMs),
-    toolName: normalizeOptionalText(input.toolName),
-    model: normalizeOptionalText(input.model),
-    error: normalizeObservabilityError(input.error),
-    details: normalizeDetails(input.details)
-  };
-}
-function normalizeObservabilityError(error) {
-  if (error == null) {
-    return void 0;
-  }
-  if (typeof error === "object" && error !== null && "message" in error) {
-    const record = error;
-    const message2 = normalizeText(record.message, "");
-    if (!message2) {
-      return void 0;
-    }
-    return {
-      message: message2,
-      code: normalizeOptionalText(record.code),
-      details: normalizeValue(record.details)
-    };
-  }
-  const message = readErrorMessage(error);
-  return message ? { message } : void 0;
-}
-function normalizeDetails(details) {
-  if (!details || typeof details !== "object") {
-    return void 0;
-  }
-  const normalized = normalizeValue(details);
-  return normalized && typeof normalized === "object" && !Array.isArray(normalized) ? normalized : void 0;
-}
-function normalizeValue(value, depth = 0) {
-  if (value == null) {
-    return void 0;
-  }
-  if (depth >= 4) {
-    return "[truncated]";
-  }
-  if (typeof value === "string") {
-    return value.length <= 2e3 ? value : `${value.slice(0, 1997)}...`;
-  }
-  if (typeof value === "number") {
-    return Number.isFinite(value) ? value : void 0;
-  }
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (value instanceof Error) {
-    return {
-      name: normalizeText(value.name, "Error"),
-      message: normalizeText(value.message, "Unknown error"),
-      stack: normalizeValue(value.stack, depth + 1)
-    };
-  }
-  if (Array.isArray(value)) {
-    return value.slice(0, 20).map((item) => normalizeValue(item, depth + 1)).filter((item) => item !== void 0);
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value).slice(0, 30);
-    const normalizedEntries = entries.map(([key, item]) => [key, normalizeValue(item, depth + 1)]).filter(([, item]) => item !== void 0);
-    return Object.fromEntries(normalizedEntries);
-  }
-  return normalizeText(String(value), "");
-}
-function normalizeText(value, fallback) {
-  const normalized = String(value ?? "").trim();
-  return normalized || fallback;
-}
-function normalizeOptionalText(value) {
-  const normalized = String(value ?? "").trim();
-  return normalized || void 0;
-}
-function normalizeOptionalNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.round(value) : void 0;
-}
-function readErrorMessage(error) {
-  if (error instanceof Error) {
-    return normalizeText(error.message, error.name || "Unknown error");
-  }
-  if (typeof error === "object" && error !== null && "message" in error) {
-    return normalizeText(error.message, "Unknown error");
-  }
-  return normalizeText(String(error ?? "Unknown error"), "Unknown error");
-}
-
-// src/observability/writer.ts
-async function appendObservabilityEvent(rootDir, input) {
-  const paths = await ensureProjectStateDirectories(rootDir);
-  const record = buildObservabilityEventRecord(input);
-  const filePath = path2.join(paths.observabilityEventsDir, `${record.timestamp.slice(0, 10)}.jsonl`);
-  await fs2.appendFile(filePath, `${JSON.stringify(record)}
-`, "utf8");
-  return record;
-}
-async function recordObservabilityEvent(rootDir, input) {
-  try {
-    await appendObservabilityEvent(rootDir, input);
-  } catch {
-  }
-}
-
-// src/provider/cachePolicy.ts
-function resolveProviderCachePolicy(input) {
-  const capabilities = resolveProviderCapabilities(input);
-  if (capabilities.provider === "openai") {
-    return {
-      provider: "openai",
-      automaticPrefixCache: true,
-      promptCacheKey: buildPromptCacheKey(input)
-    };
-  }
-  if (capabilities.provider === "deepseek") {
-    return {
-      provider: "deepseek",
-      automaticPrefixCache: true
-    };
-  }
-  return {
-    provider: "generic",
-    automaticPrefixCache: false
-  };
-}
-function buildPromptCacheKey(input) {
-  const seed = input.sessionId || input.projectRoot;
-  if (!seed) {
-    return void 0;
-  }
-  return `kitty:${stableHash(seed)}`;
-}
-function stableHash(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-
-// src/provider/chatRequestBody.ts
-function buildProviderRequestBody(input) {
-  const capabilities = resolveProviderCapabilities(input);
-  const thinking = capabilities.provider === "deepseek" ? resolveDeepSeekThinking(input.messages, input.thinking ?? "enabled") : input.thinking;
-  const body = {
-    model: input.model,
-    messages: toChatCompletionMessages(input.messages),
-    tools: input.tools,
-    stream: input.stream
-  };
-  if (capabilities.provider !== "deepseek" && input.tools?.length) {
-    body.tool_choice = "auto";
-  }
-  if (input.stream) {
-    body.stream_options = {
-      include_usage: true
-    };
-  }
-  const cachePolicy = resolveProviderCachePolicy(input);
-  if (cachePolicy.promptCacheKey) {
-    body.prompt_cache_key = cachePolicy.promptCacheKey;
-  }
-  if (typeof input.maxOutputTokens === "number" && Number.isFinite(input.maxOutputTokens)) {
-    body.max_tokens = Math.max(1, Math.trunc(input.maxOutputTokens));
-  }
-  if (capabilities.provider === "deepseek") {
-    body.thinking = { type: thinking };
-    if (thinking === "enabled") {
-      body.reasoning_effort = normalizeDeepSeekReasoningEffort(input.reasoningEffort ?? capabilities.defaultReasoningEffort);
-    }
-  } else if (input.forceReasoning || capabilities.defaultReasoningEnabled) {
-    body.thinking = { type: "enabled" };
-  }
-  return body;
-}
-function resolveDeepSeekThinking(messages, requested) {
-  if (requested === "disabled") {
-    return "disabled";
-  }
-  return hasUnreplayableAssistantReasoning(messages) ? "disabled" : "enabled";
-}
-function hasUnreplayableAssistantReasoning(messages) {
-  return messages.some(
-    (message) => message.role === "assistant" && Array.isArray(message.toolCalls) && message.toolCalls.length > 0 && message.reasoningContent === void 0
-  );
-}
-function normalizeDeepSeekReasoningEffort(effort) {
-  if (effort === void 0 || effort === "minimal" || effort === "low" || effort === "medium" || effort === "high") {
-    return "high";
-  }
-  if (effort === "xhigh" || effort === "max") {
-    return "max";
-  }
-  return "high";
-}
-
-// src/provider/chatCompletionsAdapter.ts
-var chatCompletionsAdapter = {
+var DEEPSEEK_MODEL_BASE = {
   wireApi: "chat.completions",
-  async fetchStreaming(client, request) {
-    const startedAt = Date.now();
-    let usage;
-    throwIfAborted(request.abortSignal, "Streaming request aborted");
-    try {
-      const stream = await client.chat.completions.create(
-        {
-          ...buildProviderRequestBody({
-            provider: request.provider,
-            model: request.model,
-            messages: request.messages,
-            tools: request.tools,
-            stream: true,
-            forceReasoning: request.forceReasoning,
-            thinking: request.thinking,
-            reasoningEffort: request.reasoningEffort,
-            maxOutputTokens: request.maxOutputTokens,
-            sessionId: request.sessionId,
-            projectRoot: request.projectRoot
-          }),
-          signal: request.abortSignal
-        }
-      );
-      if (request.abortSignal?.aborted) {
-        abortStream(stream);
-        throw createAbortError("Streaming aborted");
-      }
-      let content = "";
-      let reasoningContent = "";
-      const toolCallParts = /* @__PURE__ */ new Map();
-      for await (const chunk of stream) {
-        if (request.abortSignal?.aborted) {
-          abortStream(stream);
-          throw createAbortError("Streaming aborted");
-        }
-        usage = normalizeProviderUsage(chunk.usage) ?? usage;
-        const delta = chunk.choices?.[0]?.delta;
-        if (!delta) {
-          continue;
-        }
-        if (typeof delta.content === "string" && delta.content.length > 0) {
-          content += delta.content;
-          request.callbacks?.onAssistantDelta?.(delta.content);
-        }
-        if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
-          reasoningContent += delta.reasoning_content;
-          request.callbacks?.onReasoningDelta?.(delta.reasoning_content);
-        }
-        if (Array.isArray(delta.tool_calls)) {
-          for (const toolCall of delta.tool_calls) {
-            const index = typeof toolCall.index === "number" ? toolCall.index : 0;
-            const existing = toolCallParts.get(index) ?? {
-              id: toolCall.id ?? `tool-${index}`,
-              name: "",
-              arguments: ""
-            };
-            if (toolCall.id) {
-              existing.id = toolCall.id;
-            }
-            if (toolCall.function?.name) {
-              existing.name += toolCall.function.name;
-            }
-            if (toolCall.function?.arguments) {
-              existing.arguments += toolCall.function.arguments;
-            }
-            toolCallParts.set(index, existing);
-          }
-        }
-      }
-      return {
-        content: content.length > 0 ? content : null,
-        reasoningContent: reasoningContent.length > 0 ? reasoningContent : void 0,
-        streamedAssistantContent: content.length > 0,
-        streamedReasoningContent: reasoningContent.length > 0,
-        toolCalls: [...toolCallParts.entries()].sort((left, right) => left[0] - right[0]).map(([, toolCall]) => ({
-          id: toolCall.id,
-          type: "function",
-          function: {
-            name: toolCall.name,
-            arguments: toolCall.arguments
-          }
-        }))
-      };
-    } finally {
-      request.onRequestMetric?.({
-        durationMs: Date.now() - startedAt,
-        usage
-      });
-    }
+  capabilities: {
+    tools: true,
+    reasoning: true,
+    reasoningContentReplay: "tool-call-required",
+    streaming: true,
+    usage: true,
+    cache: "provider-automatic"
   },
-  async fetchNonStreaming(client, request) {
-    const startedAt = Date.now();
-    let usage;
-    throwIfAborted(request.abortSignal, "Request aborted");
-    try {
-      const completion = await client.chat.completions.create(
-        {
-          ...buildProviderRequestBody({
-            provider: request.provider,
-            model: request.model,
-            messages: request.messages,
-            tools: request.tools,
-            stream: false,
-            forceReasoning: request.forceReasoning,
-            thinking: request.thinking,
-            reasoningEffort: request.reasoningEffort,
-            maxOutputTokens: request.maxOutputTokens,
-            sessionId: request.sessionId,
-            projectRoot: request.projectRoot
-          }),
-          signal: request.abortSignal
-        }
-      );
-      usage = normalizeProviderUsage(completion.usage);
-      const message = completion.choices[0]?.message;
-      if (!message) {
-        throw new Error("API returned no message.");
-      }
-      return {
-        content: typeof message.content === "string" ? message.content : collapseContentParts(message.content),
-        reasoningContent: readReasoningContent(message),
-        streamedAssistantContent: false,
-        streamedReasoningContent: false,
-        toolCalls: (message.tool_calls ?? []).filter((call) => call.type === "function").map((call) => ({
-          id: call.id,
-          type: "function",
-          function: {
-            name: call.function.name,
-            arguments: call.function.arguments
-          }
-        }))
-      };
-    } finally {
-      request.onRequestMetric?.({
-        durationMs: Date.now() - startedAt,
-        usage
-      });
-    }
+  request: {
+    thinkingDefault: "enabled",
+    reasoningEffortDefault: "max",
+    maxOutputTokensParam: "max_tokens"
+  },
+  limit: {
+    context: 128e3,
+    output: 8e3
   }
 };
-function abortStream(stream) {
-  try {
-    stream?.controller?.abort();
-  } catch {
-  }
-}
-function toChatCompletionMessages(messages) {
-  return messages.map((message) => {
-    if (message.role === "tool") {
-      return {
-        role: "tool",
-        content: message.content ?? "",
-        tool_call_id: message.toolCallId ?? ""
-      };
-    }
-    if (message.role === "assistant" && message.toolCalls?.length) {
-      const assistantMessage = {
-        role: "assistant",
-        content: message.content ?? "",
-        tool_calls: message.toolCalls
-      };
-      if (message.reasoningContent !== void 0) {
-        assistantMessage.reasoning_content = message.reasoningContent;
-      }
-      return assistantMessage;
-    }
-    const baseMessage = {
-      role: message.role,
-      content: message.content ?? "",
-      name: message.name
-    };
-    if (message.role === "assistant" && message.reasoningContent !== void 0) {
-      baseMessage.reasoning_content = message.reasoningContent;
-    }
-    return baseMessage;
-  });
-}
-
-// src/provider/responsesAdapter.ts
-var responsesAdapter = {
+var GPT_RESPONSES_MODEL_BASE = {
   wireApi: "responses",
-  async fetchStreaming(client, request) {
-    const startedAt = Date.now();
-    let usage;
-    throwIfAborted(request.abortSignal, "Streaming request aborted");
-    try {
-      const stream = await client.responses.create(
-        {
-          ...buildResponsesRequestBody(request),
-          stream: true
-        },
-        {
-          signal: request.abortSignal
-        }
-      );
-      if (request.abortSignal?.aborted) {
-        abortStream2(stream);
-        throw createAbortError("Streaming aborted");
-      }
-      let content = "";
-      let reasoningContent = "";
-      const toolCalls = /* @__PURE__ */ new Map();
-      for await (const event of stream) {
-        if (request.abortSignal?.aborted) {
-          abortStream2(stream);
-          throw createAbortError("Streaming aborted");
-        }
-        usage = normalizeProviderUsage(event.response?.usage) ?? usage;
-        if (event.type === "response.output_text.delta" && typeof event.delta === "string") {
-          content += event.delta;
-          request.callbacks?.onAssistantDelta?.(event.delta);
-          continue;
-        }
-        if ((event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary_text.delta") && typeof event.delta === "string") {
-          reasoningContent += event.delta;
-          request.callbacks?.onReasoningDelta?.(event.delta);
-          continue;
-        }
-        if (event.type === "response.function_call_arguments.delta" && typeof event.delta === "string") {
-          const index = typeof event.output_index === "number" ? event.output_index : 0;
-          const existing = toolCalls.get(index) ?? {
-            id: event.item_id ?? `tool-${index}`,
-            name: "",
-            arguments: ""
-          };
-          existing.arguments += event.delta;
-          toolCalls.set(index, existing);
-          continue;
-        }
-        if (event.type === "response.function_call_arguments.done") {
-          const index = typeof event.output_index === "number" ? event.output_index : 0;
-          const existing = toolCalls.get(index) ?? {
-            id: event.item_id ?? `tool-${index}`,
-            name: "",
-            arguments: ""
-          };
-          if (typeof event.name === "string") {
-            existing.name = event.name;
-          }
-          if (typeof event.arguments === "string" && event.arguments.length > 0) {
-            existing.arguments = event.arguments;
-          }
-          toolCalls.set(index, existing);
-          continue;
-        }
-        if (event.type === "response.output_item.done" && event.item?.type === "function_call") {
-          const index = typeof event.output_index === "number" ? event.output_index : 0;
-          toolCalls.set(index, {
-            id: event.item.call_id ?? event.item.id ?? `tool-${index}`,
-            name: event.item.name ?? "",
-            arguments: event.item.arguments ?? ""
-          });
-        }
-      }
-      return {
-        content: content.length > 0 ? content : null,
-        reasoningContent: reasoningContent.length > 0 ? reasoningContent : void 0,
-        streamedAssistantContent: content.length > 0,
-        streamedReasoningContent: reasoningContent.length > 0,
-        toolCalls: [...toolCalls.entries()].sort((left, right) => left[0] - right[0]).map(([, toolCall]) => ({
-          id: toolCall.id,
-          type: "function",
-          function: {
-            name: toolCall.name,
-            arguments: toolCall.arguments
-          }
-        }))
-      };
-    } finally {
-      request.onRequestMetric?.({
-        durationMs: Date.now() - startedAt,
-        usage
-      });
-    }
+  capabilities: {
+    tools: true,
+    reasoning: true,
+    reasoningContentReplay: "never",
+    streaming: true,
+    usage: true,
+    cache: "prompt-cache-key"
   },
-  async fetchNonStreaming(client, request) {
-    const startedAt = Date.now();
-    let usage;
-    throwIfAborted(request.abortSignal, "Request aborted");
-    try {
-      const response = await client.responses.create(
-        {
-          ...buildResponsesRequestBody(request),
-          stream: false
-        },
-        {
-          signal: request.abortSignal
-        }
-      );
-      usage = normalizeProviderUsage(response.usage);
-      return {
-        content: normalizeOutputText(response),
-        reasoningContent: readResponseReasoning(response),
-        streamedAssistantContent: false,
-        streamedReasoningContent: false,
-        toolCalls: readResponseToolCalls(response)
-      };
-    } finally {
-      request.onRequestMetric?.({
-        durationMs: Date.now() - startedAt,
-        usage
-      });
-    }
+  request: {
+    thinkingDefault: "enabled",
+    reasoningEffortDefault: "high",
+    maxOutputTokensParam: "max_output_tokens"
+  },
+  limit: {
+    context: 4e5,
+    output: 128e3
   }
 };
-function buildResponsesRequestBody(request) {
-  const capabilities = resolveProviderCapabilities({
-    provider: request.provider,
-    model: request.model
-  });
-  const body = {
-    model: request.model,
-    input: toResponsesInput(request.messages),
-    tools: request.tools?.map((tool) => ({
-      type: "function",
-      name: tool.function.name,
-      description: tool.function.description,
-      parameters: tool.function.parameters ?? null,
-      strict: false
-    })),
-    tool_choice: request.tools?.length ? "auto" : void 0
-  };
-  if (typeof request.maxOutputTokens === "number" && Number.isFinite(request.maxOutputTokens)) {
-    body.max_output_tokens = Math.max(1, Math.trunc(request.maxOutputTokens));
-  }
-  const cachePolicy = resolveProviderCachePolicy({
-    provider: request.provider,
-    model: request.model,
-    sessionId: request.sessionId,
-    projectRoot: request.projectRoot
-  });
-  if (cachePolicy.promptCacheKey) {
-    body.prompt_cache_key = cachePolicy.promptCacheKey;
-  }
-  const reasoningEffort = normalizeResponsesReasoningEffort(
-    request.reasoningEffort ?? capabilities.defaultReasoningEffort
-  );
-  if (request.forceReasoning || capabilities.defaultReasoningEnabled || reasoningEffort) {
-    body.reasoning = {
-      effort: reasoningEffort ?? "high",
-      summary: "detailed"
-    };
-  }
-  return body;
-}
-function normalizeResponsesReasoningEffort(effort) {
-  return effort === "max" ? void 0 : effort;
-}
-function toResponsesInput(messages) {
-  const items = [];
-  for (const message of messages) {
-    if (message.role === "tool") {
-      items.push({
-        type: "function_call_output",
-        call_id: message.toolCallId ?? "",
-        output: message.content ?? ""
-      });
-      continue;
-    }
-    if (message.role === "assistant" && message.toolCalls?.length) {
-      if (typeof message.content === "string" && message.content.trim().length > 0) {
-        items.push({
-          type: "message",
-          role: "assistant",
-          content: message.content
-        });
-      }
-      for (const toolCall of message.toolCalls) {
-        items.push({
-          type: "function_call",
-          call_id: toolCall.id,
-          name: toolCall.function.name,
-          arguments: toolCall.function.arguments
-        });
-      }
-      continue;
+var MODEL_CATALOG = [
+  {
+    id: "deepseek-v4-flash",
+    providerId: "deepseek",
+    label: "DeepSeek V4 Flash",
+    ...DEEPSEEK_MODEL_BASE
+  },
+  {
+    id: "deepseek-v4-pro",
+    providerId: "deepseek",
+    label: "DeepSeek V4 Pro",
+    ...DEEPSEEK_MODEL_BASE
+  },
+  {
+    id: "gpt-5.5",
+    providerId: "yls",
+    label: "GPT-5.5 via YLS",
+    ...GPT_RESPONSES_MODEL_BASE
+  },
+  {
+    id: "gpt-5.4",
+    providerId: "yls",
+    label: "GPT-5.4 via YLS",
+    ...GPT_RESPONSES_MODEL_BASE,
+    request: {
+      ...GPT_RESPONSES_MODEL_BASE.request,
+      reasoningEffortDefault: "xhigh"
     }
-    items.push({
-      type: "message",
-      role: message.role,
-      content: message.content ?? ""
-    });
-  }
-  return items;
-}
-function normalizeOutputText(response) {
-  const outputText = response.output_text;
-  if (typeof outputText === "string" && outputText.trim().length > 0) {
-    return outputText;
-  }
-  const output = response.output;
-  if (!Array.isArray(output)) {
-    return null;
-  }
-  const fragments = output.flatMap((item) => {
-    if (!item || typeof item !== "object" || item.type !== "message") {
-      return [];
+  },
+  {
+    id: "gpt-5.4",
+    providerId: "ttapi",
+    label: "GPT-5.4 via TTAPI",
+    ...GPT_RESPONSES_MODEL_BASE,
+    request: {
+      ...GPT_RESPONSES_MODEL_BASE.request,
+      thinkingDefault: "disabled",
+      reasoningEffortDefault: "xhigh"
     }
-    const content = item.content;
-    if (!Array.isArray(content)) {
-      return [];
+  },
+  {
+    id: "gpt-5.5",
+    providerId: "openai",
+    label: "GPT-5.5",
+    ...GPT_RESPONSES_MODEL_BASE
+  },
+  {
+    id: "gpt-5.4",
+    providerId: "openai",
+    label: "GPT-5.4",
+    ...GPT_RESPONSES_MODEL_BASE,
+    request: {
+      ...GPT_RESPONSES_MODEL_BASE.request,
+      reasoningEffortDefault: "xhigh"
     }
-    return content.flatMap((part) => {
-      if (!part || typeof part !== "object" || part.type !== "output_text") {
-        return [];
-      }
-      return typeof part.text === "string" ? [part.text] : [];
-    });
-  });
-  return fragments.length > 0 ? fragments.join("") : null;
-}
-function readResponseToolCalls(response) {
-  const output = response.output;
-  if (!Array.isArray(output)) {
-    return [];
   }
-  return output.filter((item) => Boolean(item) && typeof item === "object" && item.type === "function_call").map((item) => ({
-    id: item.call_id ?? item.id ?? crypto.randomUUID(),
-    type: "function",
-    function: {
-      name: item.name ?? "",
-      arguments: item.arguments ?? ""
-    }
-  }));
+];
+function listModelInfos() {
+  return [...MODEL_CATALOG];
 }
-function readResponseReasoning(response) {
-  const output = response.output;
-  if (!Array.isArray(output)) {
-    return void 0;
-  }
-  const fragments = output.flatMap((item) => {
-    if (!item || typeof item !== "object" || item.type !== "reasoning") {
-      return [];
-    }
-    const reasoningItem = item;
-    const summary = Array.isArray(reasoningItem.summary) ? reasoningItem.summary.map((entry) => typeof entry?.text === "string" ? entry.text : "").filter(Boolean) : [];
-    const content = Array.isArray(reasoningItem.content) ? reasoningItem.content.map((entry) => typeof entry?.text === "string" ? entry.text : "").filter(Boolean) : [];
-    return [...content, ...summary];
-  });
-  return fragments.length > 0 ? fragments.join("") : void 0;
+function findProviderInfo(providerId) {
+  return PROVIDER_CATALOG.find((provider) => provider.id === normalizeProviderId(providerId));
 }
-function abortStream2(stream) {
-  try {
-    stream?.controller?.abort();
-  } catch {
+function findModelInfo(providerId, modelId) {
+  const normalizedProvider = normalizeProviderId(providerId);
+  const normalizedModel = normalizeModelId(modelId);
+  const known = MODEL_CATALOG.find((model) => model.providerId === normalizedProvider && model.id === normalizedModel);
+  if (known) {
+    return known;
+  }
+  if (normalizedProvider === "openai-compatible") {
+    return createOpenAiCompatibleModelInfo(normalizedModel);
   }
+  return void 0;
 }
-
-// src/provider/client.ts
-import OpenAI from "openai";
-
-// src/provider/connection.ts
-function buildProviderBaseUrlCandidates(baseUrl) {
-  const normalized = trimTrailingSlash(baseUrl);
-  if (!normalized) {
-    return [normalized];
+function resolveModelProfile(input) {
+  const configuredProvider = normalizeProviderId(input.provider);
+  const configuredModel = normalizeModelId(input.model);
+  const provider = findProviderInfo(configuredProvider);
+  if (!provider) {
+    throw new Error(`Unknown provider: ${configuredProvider}. Check KITTY_PROVIDER.`);
   }
-  const candidates = [normalized];
-  try {
-    const parsed = new URL(normalized);
-    if (parsed.pathname === "" || parsed.pathname === "/") {
-      candidates.push(trimTrailingSlash(new URL("v1", ensureTrailingSlash(parsed.toString())).toString()));
-    }
-  } catch {
-    return candidates;
+  const model = findModelInfo(configuredProvider, configuredModel);
+  if (!model) {
+    throw new Error(`Unknown model for provider ${configuredProvider}: ${configuredModel}. Check KITTY_MODEL.`);
   }
-  return [...new Set(candidates)];
+  return {
+    provider,
+    model,
+    configuredProvider,
+    configuredModel
+  };
 }
-function ensureTrailingSlash(baseUrl) {
-  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+function normalizeProviderId(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  return normalized || "openai-compatible";
 }
-function trimTrailingSlash(baseUrl) {
-  const trimmed = String(baseUrl ?? "").trim();
-  if (!trimmed) {
-    return trimmed;
-  }
-  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+function normalizeModelId(value) {
+  return String(value ?? "").trim();
 }
-
-// src/provider/client.ts
-function createProviderClientPool(config) {
-  const capabilities = resolveProviderCapabilities({
-    provider: config.provider,
-    model: config.model
-  });
-  const baseUrls = buildProviderBaseUrlCandidates(config.baseUrl);
-  const clients = /* @__PURE__ */ new Map();
-  let preferredBaseUrl;
+function createOpenAiCompatibleModelInfo(modelId) {
   return {
-    candidates() {
-      const ordered = preferredBaseUrl ? [preferredBaseUrl, ...baseUrls.filter((baseUrl) => baseUrl !== preferredBaseUrl)] : baseUrls;
-      return ordered.map((baseUrl) => ({
-        baseUrl,
-        client: getOrCreateClient(baseUrl)
-      }));
+    id: modelId,
+    providerId: "openai-compatible",
+    label: modelId,
+    wireApi: "chat.completions",
+    capabilities: {
+      tools: true,
+      reasoning: false,
+      reasoningContentReplay: "never",
+      streaming: true,
+      usage: true,
+      cache: "none"
+    },
+    request: {
+      thinkingDefault: "disabled",
+      maxOutputTokensParam: "max_tokens"
     },
-    markHealthy(baseUrl) {
-      preferredBaseUrl = baseUrl;
+    limit: {
+      context: 128e3,
+      output: 8e3
     }
   };
-  function getOrCreateClient(baseUrl) {
-    const existing = clients.get(baseUrl);
-    if (existing) {
-      return existing;
-    }
-    const client = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: baseUrl,
-      timeout: capabilities.requestTimeoutMs,
-      maxRetries: 0
-    });
-    clients.set(baseUrl, client);
-    return client;
-  }
-}
-function isProviderClientPool(value) {
-  return Boolean(
-    value && typeof value === "object" && typeof value.candidates === "function" && typeof value.markHealthy === "function"
-  );
 }
 
-// src/provider/request.ts
-async function fetchAssistantResponse(client, messages, request, tools, callbacks, abortSignal, onRequestMetric, observability) {
-  const capabilities = resolveProviderCapabilities(request);
-  const adapter = selectProviderWireAdapter(capabilities.wireApi);
-  return tryFetch(
-    adapter,
-    client,
-    messages,
-    request,
-    tools,
-    callbacks,
-    false,
-    abortSignal,
-    onRequestMetric,
-    observability
-  );
-}
-async function tryFetch(adapter, client, messages, request, tools, callbacks, forceReasoning, abortSignal, onRequestMetric, observability) {
-  const startedAt = Date.now();
-  let latestMetric;
-  let resolvedBaseUrl;
-  const forwardMetric = (metric) => {
-    latestMetric = metric;
-    onRequestMetric?.(metric);
+// src/provider/capabilities.ts
+function resolveProviderCapabilities(input) {
+  const profile = resolveModelProfile(input);
+  return {
+    provider: profile.provider.id,
+    model: profile.model.id,
+    wireApi: profile.model.wireApi,
+    supportsReasoningContent: profile.model.capabilities.reasoningContentReplay !== "never",
+    defaultReasoningEnabled: profile.model.capabilities.reasoning,
+    defaultReasoningEffort: profile.model.request.reasoningEffortDefault,
+    requestTimeoutMs: profile.provider.requestTimeoutMs,
+    doctorProbeTimeoutMs: profile.provider.doctorProbeTimeoutMs
   };
-  if (observability) {
-    await recordObservabilityEvent(observability.rootDir, {
-      event: "model.request",
-      status: "started",
-      sessionId: observability.sessionId,
-      identityKind: observability.identityKind,
-      identityName: observability.identityName,
-      model: request.model,
-      details: {
-        provider: request.provider,
-        configuredModel: observability.configuredModel,
-        requestModel: request.model,
-        wireApi: adapter.wireApi,
-        baseUrl: resolvedBaseUrl
-      }
-    });
-  }
-  try {
-    const response = await withApiRetries(
-      () => invokeWithProviderClients(client, async (providerClient, baseUrl) => {
-        resolvedBaseUrl = baseUrl;
-        return adapter.fetchStreaming(providerClient, {
-          provider: request.provider,
-          model: request.model,
-          messages,
-          tools,
-          callbacks,
-          forceReasoning,
-          thinking: request.thinking,
-          reasoningEffort: request.reasoningEffort,
-          maxOutputTokens: request.maxOutputTokens,
-          sessionId: request.sessionId,
-          projectRoot: request.projectRoot,
-          abortSignal,
-          onRequestMetric: forwardMetric
-        });
-      }),
-      abortSignal
-    );
-    if (observability) {
-      await recordObservabilityEvent(observability.rootDir, {
-        event: "model.request",
-        status: "completed",
-        sessionId: observability.sessionId,
-        identityKind: observability.identityKind,
-        identityName: observability.identityName,
-        model: request.model,
-        durationMs: Date.now() - startedAt,
-        details: {
-          provider: request.provider,
-          configuredModel: observability.configuredModel,
-          requestModel: request.model,
-          wireApi: adapter.wireApi,
-          baseUrl: resolvedBaseUrl,
-          usage: latestMetric?.usage,
-          usageAvailable: hasProviderUsageSnapshot(latestMetric?.usage)
-        }
-      });
-    }
-    return response;
-  } catch (error) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    try {
-      const response = await withApiRetries(
-        () => invokeWithProviderClients(client, async (providerClient, baseUrl) => {
-          resolvedBaseUrl = baseUrl;
-          return adapter.fetchNonStreaming(providerClient, {
-            provider: request.provider,
-            model: request.model,
-            messages,
-            tools,
-            callbacks,
-            forceReasoning,
-            thinking: request.thinking,
-            reasoningEffort: request.reasoningEffort,
-            maxOutputTokens: request.maxOutputTokens,
-            sessionId: request.sessionId,
-            projectRoot: request.projectRoot,
-            abortSignal,
-            onRequestMetric: forwardMetric
-          });
-        }),
-        abortSignal
-      );
-      if (observability) {
-        await recordObservabilityEvent(observability.rootDir, {
-          event: "model.request",
-          status: "completed",
-          sessionId: observability.sessionId,
-          identityKind: observability.identityKind,
-          identityName: observability.identityName,
-          model: request.model,
-          durationMs: Date.now() - startedAt,
-          details: {
-            provider: request.provider,
-            configuredModel: observability.configuredModel,
-            requestModel: request.model,
-            wireApi: adapter.wireApi,
-            baseUrl: resolvedBaseUrl,
-            usage: latestMetric?.usage,
-            usageAvailable: hasProviderUsageSnapshot(latestMetric?.usage)
-          }
-        });
-      }
-      return response;
-    } catch (fallbackError) {
-      if (!isAbortError(fallbackError) && observability) {
-        await recordObservabilityEvent(observability.rootDir, {
-          event: "model.request",
-          status: "failed",
-          sessionId: observability.sessionId,
-          identityKind: observability.identityKind,
-          identityName: observability.identityName,
-          model: request.model,
-          durationMs: Date.now() - startedAt,
-          error: fallbackError,
-          details: {
-            provider: request.provider,
-            configuredModel: observability.configuredModel,
-            requestModel: request.model,
-            wireApi: adapter.wireApi,
-            baseUrl: resolvedBaseUrl,
-            usage: latestMetric?.usage,
-            usageAvailable: hasProviderUsageSnapshot(latestMetric?.usage)
-          }
-        });
-      }
-      throw fallbackError;
-    }
-  }
-}
-function selectProviderWireAdapter(wireApi) {
-  if (wireApi === "responses") {
-    return responsesAdapter;
-  }
-  return chatCompletionsAdapter;
-}
-async function invokeWithProviderClients(client, operation) {
-  if (!isProviderClientPool(client)) {
-    return operation(client, void 0);
-  }
-  let lastError;
-  const candidates = client.candidates();
-  for (let index = 0; index < candidates.length; index += 1) {
-    const candidate = candidates[index];
-    try {
-      const result = await operation(candidate.client, candidate.baseUrl);
-      client.markHealthy(candidate.baseUrl);
-      return result;
-    } catch (error) {
-      lastError = error;
-      if (isAbortError(error)) {
-        throw error;
-      }
-      const hasMoreCandidates = index < candidates.length - 1;
-      if (!hasMoreCandidates || !canRetryWithAlternateBaseUrl(error)) {
-        throw error;
-      }
-    }
-  }
-  throw lastError;
-}
-function canRetryWithAlternateBaseUrl(error) {
-  const status = error.status;
-  const message = String(error.message ?? error).toLowerCase();
-  return status === 404 || status === 405 || message.includes("404") || message.includes("not found");
 }
 
 // src/session/messages.ts
-function buildChatMessages(systemPrompt, messages, contextWindowMessages, model) {
+function buildChatMessages(systemPrompt, messages, contextWindowMessages, model, provider) {
   const recentMessages = messages.slice(-contextWindowMessages);
   return [
     {
@@ -1215,7 +240,8 @@ function buildChatMessages(systemPrompt, messages, contextWindowMessages, model)
     },
     ...recentMessages.map(
       (message, index) => toChatMessage(message, {
-        includeReasoning: shouldIncludeStoredAssistantReasoning(recentMessages, index, model)
+        includeReasoning: shouldIncludeStoredAssistantReasoning(recentMessages, index, model, provider),
+        provider
       })
     )
   ];
@@ -1300,14 +326,17 @@ function expandStartToToolBoundary(messages, startIndex) {
   }
   return index;
 }
-function modelUsesReasoningContent(model) {
-  return resolveProviderCapabilities({ model }).supportsReasoningContent;
+function modelUsesReasoningContent(model, provider) {
+  if (provider) {
+    return resolveProviderCapabilities({ provider, model }).supportsReasoningContent;
+  }
+  return listModelInfos().some((item) => item.id === model && item.capabilities.reasoningContentReplay !== "never");
 }
 function isAssistantMessageInLatestTurn(messages, index) {
   return messages[index]?.role === "assistant" && index > findLatestUserIndex(messages);
 }
-function shouldIncludeStoredAssistantReasoning(messages, index, model) {
-  return modelUsesReasoningContent(model) && messages[index]?.role === "assistant";
+function shouldIncludeStoredAssistantReasoning(messages, index, model, provider) {
+  return resolveProviderCapabilities({ provider, model }).supportsReasoningContent && messages[index]?.role === "assistant";
 }
 
 // src/session/turnFrame.ts
@@ -1356,7 +385,7 @@ function oneLine(value) {
 }
 
 // src/session/taskStateHistory.ts
-import path3 from "path";
+import path from "path";
 function collectActiveFiles(messages) {
   const files = [];
   for (const message of messages) {
@@ -1485,7 +514,7 @@ function normalizeFilePath(value) {
   if (trimmed.length > 260) {
     return truncate(trimmed, 260);
   }
-  return trimmed.includes(path3.sep) || trimmed.includes("/") || trimmed.includes(".") ? trimmed : void 0;
+  return trimmed.includes(path.sep) || trimmed.includes("/") || trimmed.includes(".") ? trimmed : void 0;
 }
 
 // src/session/taskState.ts
@@ -1658,14 +687,14 @@ function noteSessionDiff(session, change, timestamp = (/* @__PURE__ */ new Date(
   };
 }
 function normalizeSessionDiffChange(change, timestamp) {
-  const toolName = normalizeText2(change?.toolName);
+  const toolName = normalizeText(change?.toolName);
   const changedPaths = takeLastUniquePaths(change?.changedPaths ?? []);
   if (!toolName || changedPaths.length === 0) {
     return null;
   }
   return {
     toolName,
-    changeId: normalizeText2(change?.changeId) || void 0,
+    changeId: normalizeText(change?.changeId) || void 0,
     changedPaths,
     diff: truncate2(change?.diff, MAX_DIFF_PREVIEW_CHARS),
     diagnosticsStatus: normalizeDiagnosticsStatus(change?.diagnosticsStatus),
@@ -1678,7 +707,7 @@ function takeLastUniquePaths(paths) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (let index = paths.length - 1; index >= 0; index -= 1) {
-    const normalized = normalizeText2(paths[index]);
+    const normalized = normalizeText(paths[index]);
     if (!normalized || seen.has(normalized)) {
       continue;
     }
@@ -1696,7 +725,7 @@ function normalizeDiagnosticsStatus(value) {
 function normalizeCount(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.trunc(value) : 0;
 }
-function normalizeText2(value) {
+function normalizeText(value) {
   return String(value ?? "").trim();
 }
 function truncate2(value, maxChars) {
@@ -1713,7 +742,7 @@ function takeLastUnique2(values) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (let index = values.length - 1; index >= 0; index -= 1) {
-    const normalized = normalizeText3(values[index]);
+    const normalized = normalizeText2(values[index]);
     if (!normalized || seen.has(normalized)) {
       continue;
     }
@@ -1728,7 +757,7 @@ function takeLastUnique2(values) {
 function truncate3(value) {
   return value.length <= MAX_REASON_TEXT_CHARS ? value : `${value.slice(0, MAX_REASON_TEXT_CHARS)}...`;
 }
-function normalizeText3(value) {
+function normalizeText2(value) {
   return String(value ?? "").replace(/\s+/g, " ").trim();
 }
 function clampWholeNumber(value, min, max, fallback) {
@@ -1765,9 +794,9 @@ function createProviderRecoveryTransition(input, timestamp = (/* @__PURE__ */ ne
     reason: {
       code: "recover.provider_request_retry",
       consecutiveFailures: Math.max(1, Math.trunc(input.consecutiveFailures)),
-      error: truncate3(normalizeText3(input.error?.message ?? input.error) || "request failed"),
-      configuredModel: normalizeText3(input.configuredModel) || "unknown_model",
-      requestModel: normalizeText3(input.requestModel) || "unknown_model",
+      error: truncate3(normalizeText2(input.error?.message ?? input.error) || "request failed"),
+      configuredModel: normalizeText2(input.configuredModel) || "unknown_model",
+      requestModel: normalizeText2(input.requestModel) || "unknown_model",
       contextWindowMessages: Math.max(1, Math.trunc(input.requestConfig.contextWindowMessages)),
       maxContextChars: Math.max(1, Math.trunc(input.requestConfig.maxContextChars)),
       contextSummaryChars: Math.max(1, Math.trunc(input.requestConfig.contextSummaryChars)),
@@ -1867,9 +896,9 @@ function normalizeRecoverTransition(reason, timestamp) {
     reason: {
       code: reason.code,
       consecutiveFailures: clampWholeNumber(reason.consecutiveFailures, 1, 50, 1) ?? 1,
-      error: truncate3(normalizeText3(reason.error) || "request failed"),
-      configuredModel: normalizeText3(reason.configuredModel) || "unknown_model",
-      requestModel: normalizeText3(reason.requestModel) || "unknown_model",
+      error: truncate3(normalizeText2(reason.error) || "request failed"),
+      configuredModel: normalizeText2(reason.configuredModel) || "unknown_model",
+      requestModel: normalizeText2(reason.requestModel) || "unknown_model",
       contextWindowMessages: clampWholeNumber(reason.contextWindowMessages, 1, 999, 1) ?? 1,
       maxContextChars: clampWholeNumber(reason.maxContextChars, 1, 1e6, 1) ?? 1,
       contextSummaryChars: clampWholeNumber(reason.contextSummaryChars, 1, 1e6, 1) ?? 1,
@@ -1924,7 +953,7 @@ function normalizeCheckpointFlow(flow, status, timestamp = (/* @__PURE__ */ new
   });
   return {
     phase,
-    reason: lastTransition ? formatRuntimeTransitionReason(lastTransition) : normalizeText3(flow?.reason) || void 0,
+    reason: lastTransition ? formatRuntimeTransitionReason(lastTransition) : normalizeText2(flow?.reason) || void 0,
     recoveryFailures: lastTransition?.action === "recover" ? lastTransition.reason.consecutiveFailures : phase === "recovery" ? clampWholeNumber(flow?.recoveryFailures, 1, 50, void 0) : void 0,
     runState,
     lastTransition,
@@ -1995,16 +1024,16 @@ function normalizeRunStateSource(source, status) {
 }
 
 // src/session/checkpoint/shared.ts
-import crypto2 from "crypto";
-import path4 from "path";
+import crypto from "crypto";
+import path2 from "path";
 var MAX_COMPLETED_STEPS = 8;
 var MAX_BATCH_TOOLS = 6;
 var MAX_BATCH_PATHS = 6;
 var MAX_SUMMARY_CHARS = 220;
 function fingerprintFocus(focus) {
-  return crypto2.createHash("sha1").update(focus.trim().toLowerCase()).digest("hex");
+  return crypto.createHash("sha1").update(focus.trim().toLowerCase()).digest("hex");
 }
-function normalizeText4(value) {
+function normalizeText3(value) {
   return String(value ?? "").replace(/\s+/g, " ").trim();
 }
 function truncate4(value, maxChars) {
@@ -2017,7 +1046,7 @@ function takeLastUnique3(values, limit) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (let index = values.length - 1; index >= 0; index -= 1) {
-    const normalized = normalizeText4(values[index]);
+    const normalized = normalizeText3(values[index]);
     if (!normalized || seen.has(normalized)) {
       continue;
     }
@@ -2044,7 +1073,7 @@ function safeParseObject2(raw) {
   }
 }
 function readString(value) {
-  const normalized = normalizeText4(value);
+  const normalized = normalizeText3(value);
   return normalized || void 0;
 }
 function normalizeToolBatch(toolBatch) {
@@ -2057,7 +1086,7 @@ function normalizeToolBatch(toolBatch) {
   }
   return {
     tools,
-    summary: truncate4(normalizeText4(toolBatch.summary) || `Ran ${tools.join(", ")}`, MAX_SUMMARY_CHARS),
+    summary: truncate4(normalizeText3(toolBatch.summary) || `Ran ${tools.join(", ")}`, MAX_SUMMARY_CHARS),
     changedPaths: takeLastUnique3(toolBatch.changedPaths ?? [], MAX_BATCH_PATHS),
     recordedAt: normalizeTimestamp(toolBatch.recordedAt, (/* @__PURE__ */ new Date()).toISOString())
   };
@@ -2081,7 +1110,7 @@ function deriveRecentToolBatchFromMessages(messages, timestamp) {
     startIndex -= 1;
   }
   const toolMessages = messages.slice(startIndex + 1, lastToolIndex + 1).filter((message) => message.role === "tool");
-  const toolNames = toolMessages.map((message) => normalizeText4(message.name)).filter(Boolean);
+  const toolNames = toolMessages.map((message) => normalizeText3(message.name)).filter(Boolean);
   return buildToolBatch(toolNames, toolMessages, void 0, timestamp);
 }
 function buildToolBatch(toolNames, toolMessages, changedPaths, timestamp) {
@@ -2148,7 +1177,7 @@ function createCheckpointForFocus(focus, timestamp) {
 function deriveCheckpointFromSession(session, timestamp) {
   const recentToolBatch = deriveRecentToolBatchFromMessages(session.messages, timestamp);
   return {
-    ...createCheckpointForFocus(normalizeText4(session.taskState?.focus) || void 0, timestamp),
+    ...createCheckpointForFocus(normalizeText3(session.taskState?.focus) || void 0, timestamp),
     completedSteps: deriveCompletedSteps(session),
     recentToolBatch
   };
@@ -2159,12 +1188,12 @@ function normalizeCheckpoint(checkpoint, timestamp = (/* @__PURE__ */ new Date()
   if (!checkpoint) {
     return void 0;
   }
-  const focus = normalizeText4(checkpoint.focus) || void 0;
+  const focus = normalizeText3(checkpoint.focus) || void 0;
   const status = checkpoint.status === "completed" ? "completed" : "active";
   return {
     version: 1,
     focus,
-    focusFingerprint: normalizeText4(checkpoint.focusFingerprint) || (focus ? fingerprintFocus(focus) : void 0),
+    focusFingerprint: normalizeText3(checkpoint.focusFingerprint) || (focus ? fingerprintFocus(focus) : void 0),
     status,
     completedSteps: takeLastUnique3(checkpoint.completedSteps ?? [], 8),
     recentToolBatch: normalizeToolBatch(checkpoint.recentToolBatch),
@@ -2212,7 +1241,7 @@ function noteCheckpointTurnInput(session, input, timestamp = (/* @__PURE__ */ ne
   };
 }
 function resolveCurrentFocusCheckpoint(session, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
-  const focus = normalizeText4(session.taskState?.focus) || void 0;
+  const focus = normalizeText3(session.taskState?.focus) || void 0;
   const fingerprint = focus ? fingerprintFocus(focus) : void 0;
   const checkpoint = normalizeCheckpoint(session.checkpoint, timestamp) ?? createEmptyCheckpoint(timestamp);
   if (!focus) {
@@ -2532,7 +1561,7 @@ function readSessionMemoryCurrentFocus(summary) {
 }
 
 // src/session/workset.ts
-import path5 from "path";
+import path3 from "path";
 var MAX_WORKSET_FILES = 20;
 function createEmptySessionWorkset(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
   return {
@@ -2616,9 +1645,9 @@ function normalizeWorksetEntry(value) {
   };
 }
 function normalizeDisplayPath(cwd, targetPath) {
-  const absolutePath = path5.resolve(cwd, targetPath);
-  const relative = path5.relative(cwd, absolutePath);
-  return relative && !relative.startsWith("..") && !path5.isAbsolute(relative) ? relative : absolutePath;
+  const absolutePath = path3.resolve(cwd, targetPath);
+  const relative = path3.relative(cwd, absolutePath);
+  return relative && !relative.startsWith("..") && !path3.isAbsolute(relative) ? relative : absolutePath;
 }
 function readString2(value) {
   return typeof value === "string" && value.trim() ? value : (/* @__PURE__ */ new Date()).toISOString();
@@ -2631,20 +1660,13 @@ function latestWorksetTimestamp(files) {
 }
 
 export {
-  PROJECT_STATE_DIR_NAME,
-  PROJECT_STATE_ENV_FILE_NAME,
-  PROJECT_STATE_ENV_EXAMPLE_FILE_NAME,
-  PROJECT_STATE_IGNORE_FILE_NAME,
-  PRESERVED_PROJECT_STATE_ENTRY_NAMES,
-  getProjectStatePaths,
-  ensureProjectStateDirectories,
   createEmptyAssistantResponseTransition,
   createProviderRecoveryTransition,
   createFinalizeTransition,
   createExecutionWaitYieldTransition,
   buildRunTurnResult,
   fingerprintFocus,
-  normalizeText4 as normalizeText,
+  normalizeText3 as normalizeText,
   takeLastUnique3 as takeLastUnique,
   createEmptyCheckpoint,
   normalizeCheckpoint,
@@ -2654,13 +1676,8 @@ export {
   noteCheckpointTransition,
   noteCheckpointRecovery,
   noteCheckpointCompleted,
-  isAbortError,
-  throwIfAborted,
-  sleepWithSignal,
-  isRetryableApiError,
-  recordObservabilityEvent,
-  createProviderClientPool,
-  fetchAssistantResponse,
+  resolveModelProfile,
+  resolveProviderCapabilities,
   buildChatMessages,
   createMessage,
   createToolMessage,