replicas-engine 0.1.875 → 0.1.877

package/dist/src/{chunk-OJTGCTIK.js → chunk-NTUXPZOE.js}

@@ -277,6 +277,8 @@ var FALLBACK_AGENT_MODEL = {
   relay: DEFAULT_CLAUDE_MODEL
 };
 function getDefaultAgentModel(provider, overrides) {
+  const catalogDefault = overrides?.defaultModels?.[provider];
+  if (catalogDefault !== void 0) return catalogDefault ?? "";
   const fallback = FALLBACK_AGENT_MODEL[provider];
   const options = getAgentModelOptions(provider, overrides);
   return options.includes(fallback) ? fallback : options[0];
@@ -544,124 +546,6 @@ function paginateEngineLogContent(input) {
 // ../shared/src/analytics/types.ts
 import { z as z2 } from "zod";
 
-// ../shared/src/credentials/types.ts
-var CREDENTIAL_SCOPE = {
-  USER: "user",
-  ORG: "org"
-};
-var CREDENTIAL_SCOPES = Object.values(CREDENTIAL_SCOPE);
-var CREDENTIAL_SCOPE_PRIORITY = [CREDENTIAL_SCOPE.USER, CREDENTIAL_SCOPE.ORG];
-
-// ../shared/src/credentials/agents.ts
-var CREDENTIAL_METHOD = {
-  OAUTH: "oauth",
-  API_KEY: "api_key",
-  OPENAI_COMPATIBLE: "openai-compatible",
-  FOUNDRY: "foundry",
-  BEDROCK: "bedrock",
-  OPENCODE_GO: "opencode-go",
-  ASTER: "aster",
-  OPENROUTER: "openrouter",
-  AI_GATEWAY: "ai-gateway",
-  MUSE_OAUTH: "muse-oauth"
-};
-var CREDENTIAL_TYPE = {
-  CLAUDE_OAUTH: "claude",
-  ANTHROPIC_API_KEY: "claude_anthropic_api_key",
-  CLAUDE_FOUNDRY: "claude_foundry",
-  CLAUDE_BEDROCK: "claude_bedrock",
-  CODEX_OAUTH: "codex",
-  OPENAI_API_KEY: "openai_api_key",
-  OPENAI_COMPATIBLE: "openai_compatible",
-  CODEX_FOUNDRY: "codex_foundry",
-  CURSOR_API_KEY: "cursor_api_key",
-  OPENCODE_GO_API_KEY: "opencode_go_api_key",
-  ASTER_API_KEY: "aster_api_key",
-  OPENROUTER_API_KEY: "openrouter_api_key",
-  AI_GATEWAY_API_KEY: "ai_gateway_api_key",
-  GEMINI_API_KEY: "gemini_api_key",
-  MUSE_OAUTH: "muse_oauth",
-  MUSE_API_KEY: "muse_api_key"
-};
-var INFERENCE_PROVIDER_LABELS = {
-  [CREDENTIAL_METHOD.OPENCODE_GO]: "OpenCode Go",
-  [CREDENTIAL_METHOD.ASTER]: "Aster",
-  [CREDENTIAL_METHOD.OPENROUTER]: "OpenRouter"
-};
-var AGENT_CREDENTIAL_METHODS_IN_ORDER = {
-  [AGENT.CLAUDE]: [
-    { method: CREDENTIAL_METHOD.OAUTH, credentialType: CREDENTIAL_TYPE.CLAUDE_OAUTH },
-    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.ANTHROPIC_API_KEY },
-    { method: CREDENTIAL_METHOD.FOUNDRY, credentialType: CREDENTIAL_TYPE.CLAUDE_FOUNDRY },
-    { method: CREDENTIAL_METHOD.BEDROCK, credentialType: CREDENTIAL_TYPE.CLAUDE_BEDROCK }
-  ],
-  [AGENT.CODEX]: [
-    { method: CREDENTIAL_METHOD.OAUTH, credentialType: CREDENTIAL_TYPE.CODEX_OAUTH },
-    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.OPENAI_API_KEY },
-    { method: CREDENTIAL_METHOD.OPENAI_COMPATIBLE, credentialType: CREDENTIAL_TYPE.OPENAI_COMPATIBLE },
-    { method: CREDENTIAL_METHOD.FOUNDRY, credentialType: CREDENTIAL_TYPE.CODEX_FOUNDRY }
-  ],
-  [AGENT.CURSOR]: [
-    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.CURSOR_API_KEY }
-  ],
-  [AGENT.DEEPSEEK]: [
-    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY }
-  ],
-  [AGENT.FX]: [
-    { method: CREDENTIAL_METHOD.AI_GATEWAY, credentialType: CREDENTIAL_TYPE.AI_GATEWAY_API_KEY }
-  ],
-  [AGENT.GEMINI]: [
-    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.GEMINI_API_KEY }
-  ],
-  [AGENT.KIMI]: [
-    { method: CREDENTIAL_METHOD.AI_GATEWAY, credentialType: CREDENTIAL_TYPE.AI_GATEWAY_API_KEY }
-  ],
-  [AGENT.MUSE]: [
-    { method: CREDENTIAL_METHOD.MUSE_OAUTH, credentialType: CREDENTIAL_TYPE.MUSE_OAUTH },
-    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.MUSE_API_KEY }
-  ],
-  [AGENT.OPENCODE]: [
-    { method: CREDENTIAL_METHOD.OPENCODE_GO, credentialType: CREDENTIAL_TYPE.OPENCODE_GO_API_KEY },
-    { method: CREDENTIAL_METHOD.ASTER, credentialType: CREDENTIAL_TYPE.ASTER_API_KEY },
-    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY }
-  ],
-  [AGENT.PI]: [
-    { method: CREDENTIAL_METHOD.OPENCODE_GO, credentialType: CREDENTIAL_TYPE.OPENCODE_GO_API_KEY },
-    { method: CREDENTIAL_METHOD.ASTER, credentialType: CREDENTIAL_TYPE.ASTER_API_KEY },
-    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY }
-  ]
-};
-function agentCredentialMethods(agent) {
-  return AGENT_CREDENTIAL_METHODS_IN_ORDER[agent].map((entry) => entry.method);
-}
-function getCredentialMethodLabel(agent, method) {
-  switch (method) {
-    case CREDENTIAL_METHOD.OAUTH:
-      if (agent === AGENT.CODEX) return "ChatGPT account";
-      return "Claude account";
-    case CREDENTIAL_METHOD.API_KEY:
-      if (agent === AGENT.CODEX) return "OpenAI API key";
-      if (agent === AGENT.CURSOR) return "Cursor API key";
-      if (agent === AGENT.GEMINI) return "Gemini API key";
-      if (agent === AGENT.MUSE) return "Muse API key";
-      return "Anthropic API key";
-    case CREDENTIAL_METHOD.OPENAI_COMPATIBLE:
-      return "OpenAI-compatible endpoint";
-    case CREDENTIAL_METHOD.FOUNDRY:
-      return "Microsoft Foundry";
-    case CREDENTIAL_METHOD.BEDROCK:
-      return "AWS Bedrock";
-    case CREDENTIAL_METHOD.OPENCODE_GO:
-    case CREDENTIAL_METHOD.ASTER:
-    case CREDENTIAL_METHOD.OPENROUTER:
-      return INFERENCE_PROVIDER_LABELS[method];
-    case CREDENTIAL_METHOD.AI_GATEWAY:
-      return "Vercel AI Gateway";
-    case CREDENTIAL_METHOD.MUSE_OAUTH:
-      return "Muse account";
-  }
-}
-
 // ../shared/src/result.ts
 function createSuccessResult(data) {
   return { ok: true, data };
@@ -798,6 +682,209 @@ function resolveOpenAICompatibleModelsUrl(values) {
   return values.modelsUrl || `${values.baseUrl}/models`;
 }
 
+// ../shared/src/credentials/ollama.ts
+var OLLAMA_AGENTS = ["claude", "codex", "deepseek", "kimi", "opencode", "pi"];
+function ollamaAuthEnvKeys(agent) {
+  return ["API_KEY", "BASE_URL"].map((key) => `REPLICAS_${agent.toUpperCase()}_OLLAMA_${key}`);
+}
+function ollamaAuthEnv(agent, credential) {
+  const [key, url] = ollamaAuthEnvKeys(agent);
+  return { [key]: credential.apiKey, [url]: credential.baseUrl };
+}
+function readOllamaAuthEnv(agent, env) {
+  const [key, url] = ollamaAuthEnvKeys(agent);
+  const apiKey = env[key];
+  const baseUrl = env[url];
+  return apiKey && baseUrl ? { apiKey, baseUrl } : null;
+}
+
+// ../shared/src/credentials/ollama-models.ts
+var DEFAULT_OLLAMA_MODEL = "gpt-oss:20b";
+var catalogs = /* @__PURE__ */ new Map();
+function getDefaultOllamaModel(models) {
+  return models.find((model) => model.id === DEFAULT_OLLAMA_MODEL && model.capabilities?.includes("tools") && (model.contextWindow ?? 0) >= 64e3)?.id ?? null;
+}
+function parseOllamaModelDetails(model, payload) {
+  if (!isRecord(payload)) return model;
+  const capabilities = Array.isArray(payload.capabilities) ? payload.capabilities.filter((value) => typeof value === "string") : void 0;
+  const info = isRecord(payload.model_info) ? payload.model_info : {};
+  const context = Object.entries(info).find(([key]) => key.endsWith(".context_length"))?.[1];
+  const configured = typeof payload.parameters === "string" ? /(?:^|\n)\s*num_ctx\s+(\d+)/.exec(payload.parameters)?.[1] : void 0;
+  const contextWindow = configured ? Number(configured) : context;
+  return {
+    ...model,
+    ...capabilities ? { capabilities } : {},
+    ...typeof contextWindow === "number" && Number.isSafeInteger(contextWindow) && contextWindow > 0 ? { contextWindow } : {}
+  };
+}
+function listOllamaModels(credential) {
+  const key = JSON.stringify([credential.baseUrl, credential.apiKey]);
+  const cached = catalogs.get(key);
+  if (cached && cached.expiresAt > Date.now()) return cached.models;
+  const models = loadOllamaModels(credential).catch((error) => {
+    if (catalogs.get(key)?.models === models) catalogs.delete(key);
+    throw error;
+  });
+  catalogs.set(key, { expiresAt: Date.now() + 6e4, models });
+  return models;
+}
+async function loadOllamaModels(credential) {
+  const models = await listOpenAICompatibleModels({ apiKey: credential.apiKey, baseUrl: `${credential.baseUrl}/v1` });
+  const url = `${credential.baseUrl}/api/show`;
+  validateExternalApiHost(url, "Ollama model details");
+  const detailed = [];
+  const signal = AbortSignal.timeout(1e4);
+  for (let offset = 0; offset < models.length; offset += 10) {
+    if (signal.aborted) {
+      detailed.push(...models.slice(offset));
+      break;
+    }
+    detailed.push(...await Promise.all(models.slice(offset, offset + 10).map(async (model) => {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          redirect: "error",
+          signal,
+          headers: { Authorization: `Bearer ${credential.apiKey}`, "Content-Type": "application/json" },
+          body: JSON.stringify({ model: model.id })
+        });
+        return response.ok ? parseOllamaModelDetails(model, await response.json()) : model;
+      } catch {
+        return model;
+      }
+    })));
+  }
+  return detailed.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+// ../shared/src/credentials/types.ts
+var CREDENTIAL_SCOPE = {
+  USER: "user",
+  ORG: "org"
+};
+var CREDENTIAL_SCOPES = Object.values(CREDENTIAL_SCOPE);
+var CREDENTIAL_SCOPE_PRIORITY = [CREDENTIAL_SCOPE.USER, CREDENTIAL_SCOPE.ORG];
+
+// ../shared/src/credentials/agents.ts
+var CREDENTIAL_METHOD = {
+  OAUTH: "oauth",
+  API_KEY: "api_key",
+  OPENAI_COMPATIBLE: "openai-compatible",
+  OLLAMA: "ollama",
+  FOUNDRY: "foundry",
+  BEDROCK: "bedrock",
+  OPENCODE_GO: "opencode-go",
+  ASTER: "aster",
+  OPENROUTER: "openrouter",
+  AI_GATEWAY: "ai-gateway",
+  MUSE_OAUTH: "muse-oauth"
+};
+var CREDENTIAL_TYPE = {
+  CLAUDE_OAUTH: "claude",
+  ANTHROPIC_API_KEY: "claude_anthropic_api_key",
+  CLAUDE_FOUNDRY: "claude_foundry",
+  CLAUDE_BEDROCK: "claude_bedrock",
+  CODEX_OAUTH: "codex",
+  OPENAI_API_KEY: "openai_api_key",
+  OPENAI_COMPATIBLE: "openai_compatible",
+  OLLAMA: "ollama",
+  CODEX_FOUNDRY: "codex_foundry",
+  CURSOR_API_KEY: "cursor_api_key",
+  OPENCODE_GO_API_KEY: "opencode_go_api_key",
+  ASTER_API_KEY: "aster_api_key",
+  OPENROUTER_API_KEY: "openrouter_api_key",
+  AI_GATEWAY_API_KEY: "ai_gateway_api_key",
+  GEMINI_API_KEY: "gemini_api_key",
+  MUSE_OAUTH: "muse_oauth",
+  MUSE_API_KEY: "muse_api_key"
+};
+var INFERENCE_PROVIDER_LABELS = {
+  [CREDENTIAL_METHOD.OLLAMA]: "Ollama",
+  [CREDENTIAL_METHOD.OPENCODE_GO]: "OpenCode Go",
+  [CREDENTIAL_METHOD.ASTER]: "Aster",
+  [CREDENTIAL_METHOD.OPENROUTER]: "OpenRouter"
+};
+var AGENT_CREDENTIAL_METHODS_IN_ORDER = {
+  [AGENT.CLAUDE]: [
+    { method: CREDENTIAL_METHOD.OAUTH, credentialType: CREDENTIAL_TYPE.CLAUDE_OAUTH },
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.ANTHROPIC_API_KEY },
+    { method: CREDENTIAL_METHOD.FOUNDRY, credentialType: CREDENTIAL_TYPE.CLAUDE_FOUNDRY },
+    { method: CREDENTIAL_METHOD.BEDROCK, credentialType: CREDENTIAL_TYPE.CLAUDE_BEDROCK },
+    { method: CREDENTIAL_METHOD.OLLAMA, credentialType: CREDENTIAL_TYPE.OLLAMA }
+  ],
+  [AGENT.CODEX]: [
+    { method: CREDENTIAL_METHOD.OAUTH, credentialType: CREDENTIAL_TYPE.CODEX_OAUTH },
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.OPENAI_API_KEY },
+    { method: CREDENTIAL_METHOD.OPENAI_COMPATIBLE, credentialType: CREDENTIAL_TYPE.OPENAI_COMPATIBLE },
+    { method: CREDENTIAL_METHOD.FOUNDRY, credentialType: CREDENTIAL_TYPE.CODEX_FOUNDRY },
+    { method: CREDENTIAL_METHOD.OLLAMA, credentialType: CREDENTIAL_TYPE.OLLAMA }
+  ],
+  [AGENT.CURSOR]: [
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.CURSOR_API_KEY }
+  ],
+  [AGENT.DEEPSEEK]: [
+    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OLLAMA, credentialType: CREDENTIAL_TYPE.OLLAMA }
+  ],
+  [AGENT.FX]: [
+    { method: CREDENTIAL_METHOD.AI_GATEWAY, credentialType: CREDENTIAL_TYPE.AI_GATEWAY_API_KEY }
+  ],
+  [AGENT.GEMINI]: [
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.GEMINI_API_KEY }
+  ],
+  [AGENT.KIMI]: [
+    { method: CREDENTIAL_METHOD.AI_GATEWAY, credentialType: CREDENTIAL_TYPE.AI_GATEWAY_API_KEY },
+    { method: CREDENTIAL_METHOD.OLLAMA, credentialType: CREDENTIAL_TYPE.OLLAMA }
+  ],
+  [AGENT.MUSE]: [
+    { method: CREDENTIAL_METHOD.MUSE_OAUTH, credentialType: CREDENTIAL_TYPE.MUSE_OAUTH },
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.MUSE_API_KEY }
+  ],
+  [AGENT.OPENCODE]: [
+    { method: CREDENTIAL_METHOD.OPENCODE_GO, credentialType: CREDENTIAL_TYPE.OPENCODE_GO_API_KEY },
+    { method: CREDENTIAL_METHOD.ASTER, credentialType: CREDENTIAL_TYPE.ASTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OLLAMA, credentialType: CREDENTIAL_TYPE.OLLAMA }
+  ],
+  [AGENT.PI]: [
+    { method: CREDENTIAL_METHOD.OPENCODE_GO, credentialType: CREDENTIAL_TYPE.OPENCODE_GO_API_KEY },
+    { method: CREDENTIAL_METHOD.ASTER, credentialType: CREDENTIAL_TYPE.ASTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OLLAMA, credentialType: CREDENTIAL_TYPE.OLLAMA }
+  ]
+};
+function agentCredentialMethods(agent) {
+  return AGENT_CREDENTIAL_METHODS_IN_ORDER[agent].map((entry) => entry.method);
+}
+function getCredentialMethodLabel(agent, method) {
+  switch (method) {
+    case CREDENTIAL_METHOD.OAUTH:
+      if (agent === AGENT.CODEX) return "ChatGPT account";
+      return "Claude account";
+    case CREDENTIAL_METHOD.API_KEY:
+      if (agent === AGENT.CODEX) return "OpenAI API key";
+      if (agent === AGENT.CURSOR) return "Cursor API key";
+      if (agent === AGENT.GEMINI) return "Gemini API key";
+      if (agent === AGENT.MUSE) return "Muse API key";
+      return "Anthropic API key";
+    case CREDENTIAL_METHOD.OPENAI_COMPATIBLE:
+      return "OpenAI-compatible endpoint";
+    case CREDENTIAL_METHOD.FOUNDRY:
+      return "Microsoft Foundry";
+    case CREDENTIAL_METHOD.BEDROCK:
+      return "AWS Bedrock";
+    case CREDENTIAL_METHOD.OLLAMA:
+    case CREDENTIAL_METHOD.OPENCODE_GO:
+    case CREDENTIAL_METHOD.ASTER:
+    case CREDENTIAL_METHOD.OPENROUTER:
+      return INFERENCE_PROVIDER_LABELS[method];
+    case CREDENTIAL_METHOD.AI_GATEWAY:
+      return "Vercel AI Gateway";
+    case CREDENTIAL_METHOD.MUSE_OAUTH:
+      return "Muse account";
+  }
+}
+
 // ../shared/src/pricing.ts
 var WORKSPACE_SOURCES = ["api", "dashboard", "slack", "linear", "github", "gitlab", "automation", "mothership"];
 var CLIENT_MESSAGE_SOURCES = ["web", "desktop", "mobile", "tui"];
@@ -3911,6 +3998,15 @@ function removeReplicasInstructions(text) {
   return removeTag(text, REPLICAS_INSTRUCTIONS_TAG);
 }
 
+// ../shared/src/user-message-matching.ts
+function parseTimestampMs(timestamp) {
+  const value = typeof timestamp === "number" ? timestamp : Date.parse(timestamp);
+  return Number.isFinite(value) ? value : 0;
+}
+function areUserMessagesWithinMatchWindow(a, b) {
+  return a.content === b.content && Math.abs(parseTimestampMs(a.timestamp) - parseTimestampMs(b.timestamp)) <= USER_MESSAGE_MATCH_GRACE_PERIOD_MS;
+}
+
 // ../shared/src/display-message/parsers/codex-asp-parser.ts
 function collectCodexTurns(events) {
   const turns = /* @__PURE__ */ new Map();
@@ -4178,6 +4274,25 @@ function parsePatch(input) {
   }
   return operations;
 }
+function takeRecordedPrompt(prompts, echo, turnIndex) {
+  const timestampMs = parseTimestampMs(echo.timestamp);
+  let closestIndex = -1;
+  let closestDistance = Infinity;
+  for (let i = prompts.length - 1; i >= 0; i--) {
+    const candidate = prompts[i];
+    const distance = Math.abs(candidate.timestampMs - timestampMs);
+    if (distance > closestDistance) continue;
+    if (candidate.index >= turnIndex && !areUserMessagesWithinMatchWindow(
+      { content: candidate.message.content, timestamp: candidate.timestampMs },
+      { content: echo.content, timestamp: timestampMs }
+    )) continue;
+    const images = candidate.message.images;
+    if (images && echo.images && (images.length !== echo.images.length || images.some((image, index) => image.mediaType !== echo.images?.[index].mediaType || image.data !== echo.images?.[index].data))) continue;
+    closestIndex = i;
+    closestDistance = distance;
+  }
+  return closestIndex === -1 ? void 0 : prompts.splice(closestIndex, 1)[0].message;
+}
 function parseCodexEvents(events) {
   const messages = [];
   const turns = collectCodexTurns(events);
@@ -4361,26 +4476,35 @@ function parseCodexEvents(events) {
       }
     }
   });
+  const recordedPrompts = /* @__PURE__ */ new Map();
+  messages.forEach((message, index) => {
+    if (message.type !== "user") return;
+    const prompts = recordedPrompts.get(message.content) ?? [];
+    prompts.push({ message, index, timestampMs: parseTimestampMs(message.timestamp) });
+    recordedPrompts.set(message.content, prompts);
+  });
   const claimedPrompts = /* @__PURE__ */ new Set();
   for (const { index, turnId } of turnInsertions.reverse()) {
     const turn = turns.get(turnId);
     if (!turn) continue;
     const kept = [];
     for (const message of messagesForCodexTurn(turn)) {
-      const recordedIndex = message.type === "user" ? messages.findLastIndex((candidate, candidateIndex) => candidateIndex < index && candidate.type === "user" && candidate.content === message.content && !claimedPrompts.has(candidateIndex)) : -1;
-      if (recordedIndex === -1) {
+      if (message.type !== "user") {
         kept.push(message);
         continue;
       }
-      claimedPrompts.add(recordedIndex);
-      const recorded = messages[recordedIndex];
-      if (recorded.type === "user" && message.type === "user" && !recorded.images && message.images) {
-        messages[recordedIndex] = { ...recorded, images: message.images };
+      const prompts = recordedPrompts.get(message.content);
+      const recorded = prompts && takeRecordedPrompt(prompts, message, index);
+      if (!recorded) {
+        kept.push(message);
+        continue;
       }
+      claimedPrompts.add(recorded);
+      kept.push({ ...recorded, images: recorded.images ?? message.images });
     }
     messages.splice(index, 0, ...kept);
   }
-  return messages;
+  return messages.filter((message) => !claimedPrompts.has(message));
 }
 
 // ../shared/src/display-message/parsers/cursor-parser.ts
@@ -5397,15 +5521,6 @@ function parseMcpToolName(name) {
   return { server, tool };
 }
 
-// ../shared/src/user-message-matching.ts
-function parseTimestampMs(timestamp) {
-  const value = Date.parse(timestamp);
-  return Number.isFinite(value) ? value : 0;
-}
-function areUserMessagesWithinMatchWindow(a, b) {
-  return a.content === b.content && Math.abs(parseTimestampMs(a.timestamp) - parseTimestampMs(b.timestamp)) <= USER_MESSAGE_MATCH_GRACE_PERIOD_MS;
-}
-
 // ../shared/src/display-message/parsers/claude-parser.ts
 var ABORTED_TERMINAL_REASONS = /* @__PURE__ */ new Set(["aborted_streaming", "aborted_tools"]);
 function createSubagentMessage(messageIndex, timestamp, fields) {
@@ -6948,6 +7063,8 @@ function hasChatStarted(chat) {
 
 // ../shared/src/routes/codex.ts
 var CODEX_AUTH_ENV_KEYS = [
+  "REPLICAS_CODEX_OLLAMA_API_KEY",
+  "REPLICAS_CODEX_OLLAMA_BASE_URL",
   "OPENAI_API_KEY",
   "CODEX_OPENAI_BASE_URL",
   "CODEX_OPENAI_MODELS_URL",
@@ -6968,6 +7085,12 @@ function codexOpenAICompatibleAuthEnv(response) {
 }
 function codexAuthEnvFromResponse(response) {
   switch (response.type) {
+    case "ollama":
+      return {
+        ...codexOpenAICompatibleAuthEnv({ apiKey: response.apiKey, baseUrl: `${response.baseUrl}/v1` }),
+        ...ollamaAuthEnv("codex", response),
+        REPLICAS_CODEX_AUTH_METHOD: "ollama"
+      };
     case "oauth":
       return { REPLICAS_CODEX_AUTH_METHOD: "oauth" };
     case "api_key":
@@ -7003,6 +7126,7 @@ var CODEX_AUTH_ENV_KEYS_BY_METHOD = {
     "CODEX_OPENAI_AUTHORIZATION_HEADER",
     "REPLICAS_CODEX_AUTH_METHOD"
   ],
+  ollama: ["OPENAI_API_KEY", "CODEX_OPENAI_BASE_URL", "REPLICAS_CODEX_AUTH_METHOD", "REPLICAS_CODEX_OLLAMA_API_KEY", "REPLICAS_CODEX_OLLAMA_BASE_URL"],
   bedrock: [],
   foundry: ["AZURE_OPENAI_API_KEY", "CODEX_FOUNDRY_BASE_URL", "CODEX_FOUNDRY_MODEL", "REPLICAS_CODEX_AUTH_METHOD"]
 };
@@ -7010,6 +7134,8 @@ var CODEX_AUTH_ENV_KEYS_BY_METHOD = {
 // ../shared/src/routes/claude.ts
 var CLAUDE_AUTH_ENV_KEYS = [
   "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_BASE_URL",
   "CLAUDE_CODE_USE_BEDROCK",
   "AWS_ACCESS_KEY_ID",
   "AWS_SECRET_ACCESS_KEY",
@@ -7025,6 +7151,13 @@ var CLAUDE_AUTH_ENV_KEYS = [
 ];
 function claudeAuthEnvFromResponse(response) {
   switch (response.type) {
+    case "ollama":
+      return {
+        ANTHROPIC_API_KEY: "",
+        ANTHROPIC_AUTH_TOKEN: response.apiKey,
+        ANTHROPIC_BASE_URL: response.baseUrl,
+        REPLICAS_CLAUDE_AUTH_METHOD: "ollama"
+      };
     case "oauth":
       return { REPLICAS_CLAUDE_AUTH_METHOD: "oauth" };
     case "api_key":
@@ -7055,6 +7188,7 @@ var CLAUDE_AUTH_ENV_KEYS_BY_METHOD = {
   oauth: ["REPLICAS_CLAUDE_AUTH_METHOD"],
   api_key: ["ANTHROPIC_API_KEY", "REPLICAS_CLAUDE_AUTH_METHOD"],
   "openai-compatible": [],
+  ollama: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL", "REPLICAS_CLAUDE_AUTH_METHOD"],
   bedrock: [
     "CLAUDE_CODE_USE_BEDROCK",
     "AWS_ACCESS_KEY_ID",
@@ -7926,10 +8060,15 @@ export {
   codexReasoningEffortForThinkingLevel,
   getProviderDisplayName,
   detectAgentQuotaLimit,
-  CREDENTIAL_METHOD,
-  AGENT_CREDENTIAL_METHODS_IN_ORDER,
   listOpenAICompatibleModels,
   resolveOpenAICompatibleModelsUrl,
+  OLLAMA_AGENTS,
+  readOllamaAuthEnv,
+  DEFAULT_OLLAMA_MODEL,
+  getDefaultOllamaModel,
+  listOllamaModels,
+  CREDENTIAL_METHOD,
+  AGENT_CREDENTIAL_METHODS_IN_ORDER,
   agentCredentialSnapshotSchema,
   isAgentChatTurnActivityRecord,
   isAgentChatSkillActivityRecord,
@@ -8041,13 +8180,13 @@ export {
   MEMORY_ROOT,
   MEMORY_INDEX_FILENAME,
   MEMORY_MARKER_GUIDANCE,
+  areUserMessagesWithinMatchWindow,
   extractErrorText,
   isTransientErrorText,
   extractToolResultText,
   normalizeContentBlocks,
   TaskAccumulator,
   parseMcpToolName,
-  areUserMessagesWithinMatchWindow,
   coerceClaudeResultPayload,
   stripAgentDiagnosticErrors,
   isClaudeResultError,

package/dist/src/{chunk-YZJKOKGE.js → chunk-VJQGQEZV.js}

@@ -4,7 +4,7 @@ const require = __createRequire(import.meta.url);
 import {
   HOOK_EXEC_MAX_BUFFER_BYTES,
   isVersionBelow
-} from "./chunk-OJTGCTIK.js";
+} from "./chunk-NTUXPZOE.js";
 
 // src/utils/codex-agent-env.ts
 function buildCodexAgentEnv(source = process.env) {
@@ -241,7 +241,11 @@ var DEFAULT_CODEX_ARGS = [
 var MIN_CODEX_CLI_VERSION = "0.153.3";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.875";
+function getCodexModelProvider(method) {
+  if (method === "foundry") return "azure";
+  return method === "ollama" || method === "openai-compatible" ? "replicas_openai_compatible" : "openai";
+}
+var ENGINE_PACKAGE_VERSION = "0.1.877";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -266,7 +270,7 @@ var AppServerProcess = class {
         "-c",
         `model=${JSON.stringify(options.env.CODEX_FOUNDRY_MODEL)}`,
         "-c",
-        'model_provider="azure"',
+        `model_provider=${JSON.stringify(getCodexModelProvider(options.env.REPLICAS_CODEX_AUTH_METHOD))}`,
         "-c",
         'model_providers.azure.name="Azure OpenAI"',
         "-c",
@@ -276,11 +280,15 @@ var AppServerProcess = class {
         "-c",
         'model_providers.azure.wire_api="responses"'
       ];
-    } else if (!options.args && options.env.REPLICAS_CODEX_AUTH_METHOD === "openai-compatible") {
+    } else if (!options.args && (options.env.REPLICAS_CODEX_AUTH_METHOD === "openai-compatible" || options.env.REPLICAS_CODEX_AUTH_METHOD === "ollama")) {
       baseArgs = [
         ...DEFAULT_CODEX_ARGS,
+        ...options.env.REPLICAS_CODEX_AUTH_METHOD === "ollama" ? [
+          "-c",
+          'web_search="disabled"'
+        ] : [],
         "-c",
-        'model_provider="replicas_openai_compatible"',
+        `model_provider=${JSON.stringify(getCodexModelProvider(options.env.REPLICAS_CODEX_AUTH_METHOD))}`,
         "-c",
         'model_providers.replicas_openai_compatible.name="OpenAI Compatible"',
         "-c",
@@ -480,5 +488,6 @@ export {
   execAsync,
   execFileAsync,
   SUBPROCESS_MAX_BUFFER,
+  getCodexModelProvider,
   AppServerProcess
 };

package/dist/src/command-protection-hook.js

@@ -3,12 +3,12 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   evaluateCommandProtection
-} from "./chunk-M4NXJJHV.js";
-import "./chunk-CZLOYOGI.js";
+} from "./chunk-DOC4BA3P.js";
+import "./chunk-MOJN6DR4.js";
 import {
   isRecord
 } from "./chunk-UZSNFLDQ.js";
-import "./chunk-OJTGCTIK.js";
+import "./chunk-NTUXPZOE.js";
 import "./chunk-VEQXQN22.js";
 
 // src/command-protection-hook.ts

package/dist/src/deepseek-command-protection-plugin.js

@@ -3,13 +3,13 @@ import { createRequire as __createRequire } from 'node:module';
 const require = __createRequire(import.meta.url);
 import {
   evaluateCommandProtection
-} from "./chunk-M4NXJJHV.js";
+} from "./chunk-DOC4BA3P.js";
 import {
   notifyPostToolUse
-} from "./chunk-2QTX7QUN.js";
-import "./chunk-CZLOYOGI.js";
+} from "./chunk-37NX5RE5.js";
+import "./chunk-MOJN6DR4.js";
 import "./chunk-UZSNFLDQ.js";
-import "./chunk-OJTGCTIK.js";
+import "./chunk-NTUXPZOE.js";
 import "./chunk-VEQXQN22.js";
 
 // src/deepseek-command-protection-plugin.ts

package/dist/src/headless-agent.js

@@ -8,12 +8,12 @@ import {
 import {
   AppServerProcess,
   buildCodexAgentEnv
-} from "./chunk-YZJKOKGE.js";
+} from "./chunk-VJQGQEZV.js";
 import {
   AGENT,
   getMemoryOutputSafetyViolation,
   headlessAgentRequestSchema
-} from "./chunk-OJTGCTIK.js";
+} from "./chunk-NTUXPZOE.js";
 import "./chunk-VEQXQN22.js";
 
 // src/headless-agent.ts