@codelia/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2283 @@
+// src/config/register.ts
+import { configRegistry } from "@codelia/config";
+
+// src/models/openai.ts
+var OPENAI_DEFAULT_MODEL = "gpt-5.2-codex";
+var OPENAI_DEFAULT_REASONING_EFFORT = "medium";
+var OPENAI_MODELS = [
+  {
+    id: OPENAI_DEFAULT_MODEL,
+    provider: "openai",
+    aliases: ["default"]
+  },
+  {
+    id: "gpt-5.2",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.3-codex",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.2-2025-12-11",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.2-pro",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.2-pro-2025-12-11",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.1",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.1-2025-11-13",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5-mini",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5-mini-2025-08-07",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5-nano",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5-nano-2025-08-07",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.1-codex",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.1-codex-max",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5.1-codex-mini",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5-codex",
+    provider: "openai"
+  },
+  {
+    id: "gpt-5-codex-mini",
+    provider: "openai"
+  }
+];
+
+// src/config/register.ts
+configRegistry.registerDefaults({
+  model: {
+    provider: "openai",
+    name: OPENAI_DEFAULT_MODEL,
+    reasoning: OPENAI_DEFAULT_REASONING_EFFORT
+  }
+});
+
+// src/content/stringify.ts
+var stringifyUnknown = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var stringifyPart = (part, options) => {
+  if (part.type === "text") {
+    return part.text;
+  }
+  if (part.type === "image_url") {
+    if (options.mode === "log") {
+      return `[image:${part.image_url.media_type ?? "unknown"}]`;
+    }
+    return "[image]";
+  }
+  if (part.type === "document") {
+    if (options.mode === "log") {
+      return "[document:application/pdf]";
+    }
+    return "[document]";
+  }
+  if (part.type === "other") {
+    const head = `[other:${part.provider}/${part.kind}]`;
+    if (options.mode === "log" && options.includeOtherPayload) {
+      return `${head} ${stringifyUnknown(part.payload)}`;
+    }
+    return head;
+  }
+  return "[content]";
+};
+var stringifyContentParts = (content, options = {}) => {
+  const normalized = {
+    mode: options.mode ?? "display",
+    joiner: options.joiner ?? (options.mode === "log" ? "\n" : ""),
+    includeOtherPayload: options.includeOtherPayload ?? false
+  };
+  const text = content.map((part) => stringifyPart(part, normalized)).join(normalized.joiner);
+  return text || stringifyUnknown(content);
+};
+var stringifyContent = (content, options = {}) => {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  return stringifyContentParts(content, options);
+};
+
+// src/history/store.ts
+var MessageHistoryAdapter = class {
+  messages = [];
+  hasSystem = false;
+  enqueueSystem(system) {
+    if (system && !this.hasSystem) {
+      this.messages.push(system);
+      this.hasSystem = true;
+    }
+  }
+  enqueueUserMessage(content) {
+    const message = {
+      role: "user",
+      content
+    };
+    this.messages.push(message);
+  }
+  enqueueToolResult(message) {
+    this.messages.push(message);
+  }
+  commitModelResponse(response) {
+    this.messages.push(...response.messages);
+  }
+  prepareInvokeInput(params) {
+    return {
+      messages: this.messages,
+      tools: params.tools ?? null,
+      toolChoice: params.toolChoice ?? null
+    };
+  }
+  getViewMessages() {
+    return this.messages;
+  }
+  replaceViewMessages(messages) {
+    this.messages = messages;
+    this.hasSystem = messages.some((message) => message.role === "system");
+  }
+};
+
+// src/llm/openai/history.ts
+var OpenAIHistoryAdapter = class extends MessageHistoryAdapter {
+};
+
+// src/models/anthropic.ts
+var ANTHROPIC_DEFAULT_MODEL = "claude-sonnet-4-5";
+var ANTHROPIC_MODELS = [
+  {
+    id: ANTHROPIC_DEFAULT_MODEL,
+    provider: "anthropic",
+    aliases: ["default"]
+  },
+  {
+    id: "claude-opus-4-6",
+    provider: "anthropic"
+  },
+  {
+    id: "claude-opus-4-5",
+    provider: "anthropic"
+  },
+  {
+    id: "claude-opus-4-5-20251201",
+    provider: "anthropic"
+  },
+  {
+    id: "claude-sonnet-4-5-20250929",
+    provider: "anthropic"
+  },
+  {
+    id: "claude-haiku-4-5",
+    provider: "anthropic"
+  },
+  {
+    id: "claude-haiku-4-5-20250929",
+    provider: "anthropic"
+  }
+];
+
+// src/models/google.ts
+var GOOGLE_MODELS = [
+  {
+    id: "gemini-3-pro-preview",
+    provider: "google"
+  },
+  {
+    id: "gemini-3-pro-image-preview",
+    provider: "google"
+  },
+  {
+    id: "gemini-3-flash-preview",
+    provider: "google"
+  }
+];
+
+// src/models/registry.ts
+function createModelRegistry(specs) {
+  const registry = {
+    modelsById: {},
+    aliasesByProvider: {
+      openai: {},
+      anthropic: {},
+      google: {}
+    }
+  };
+  registerModels(registry, specs);
+  return registry;
+}
+function registerModels(registry, specs) {
+  for (const spec of specs) {
+    registry.modelsById[spec.id] = spec;
+    const aliasBucket = registry.aliasesByProvider[spec.provider];
+    for (const alias of spec.aliases ?? []) {
+      aliasBucket[alias] = spec.id;
+    }
+  }
+}
+function resolveModel(registry, idOrAlias, provider) {
+  const direct = registry.modelsById[idOrAlias];
+  if (direct) {
+    return direct;
+  }
+  if (provider) {
+    const aliasId = registry.aliasesByProvider[provider][idOrAlias];
+    return aliasId ? registry.modelsById[aliasId] : void 0;
+  }
+  let resolved;
+  for (const providerName of Object.keys(
+    registry.aliasesByProvider
+  )) {
+    const aliasId = registry.aliasesByProvider[providerName][idOrAlias];
+    if (!aliasId) {
+      continue;
+    }
+    if (resolved) {
+      return void 0;
+    }
+    resolved = registry.modelsById[aliasId];
+  }
+  return resolved;
+}
+function listModels(registry, provider) {
+  const all = Object.values(registry.modelsById);
+  return provider ? all.filter((model) => model.provider === provider) : all;
+}
+function cloneAliases(aliasesByProvider) {
+  return {
+    openai: { ...aliasesByProvider.openai },
+    anthropic: { ...aliasesByProvider.anthropic },
+    google: { ...aliasesByProvider.google }
+  };
+}
+function applyModelMetadata(registry, index) {
+  const next = {
+    modelsById: { ...registry.modelsById },
+    aliasesByProvider: cloneAliases(registry.aliasesByProvider)
+  };
+  for (const [providerId, providerModels] of Object.entries(index.models)) {
+    if (providerId !== "openai" && providerId !== "anthropic" && providerId !== "google") {
+      continue;
+    }
+    const provider = providerId;
+    for (const [modelId, entry] of Object.entries(providerModels)) {
+      const fullId = `${provider}/${modelId}`;
+      const spec = resolveModel(next, fullId, provider) ?? resolveModel(next, modelId, provider);
+      if (!spec) continue;
+      const limits = entry.limits;
+      if (!limits) continue;
+      next.modelsById[spec.id] = {
+        ...spec,
+        contextWindow: spec.contextWindow ?? limits.contextWindow,
+        maxInputTokens: spec.maxInputTokens ?? limits.inputTokens,
+        maxOutputTokens: spec.maxOutputTokens ?? limits.outputTokens
+      };
+    }
+  }
+  return next;
+}
+
+// src/models/index.ts
+var DEFAULT_MODEL_REGISTRY = createModelRegistry([
+  ...OPENAI_MODELS,
+  ...ANTHROPIC_MODELS,
+  ...GOOGLE_MODELS
+]);
+
+// src/services/compaction/service.ts
+var DEFAULT_THRESHOLD_RATIO = 0.8;
+var DEFAULT_RETAIN_LAST_TURNS = 1;
+var DEFAULT_SUMMARY_PROMPT = "Summarize the conversation so it can be continued later. Focus on decisions, results, constraints, and next steps. Keep it concise and factual.";
+var DEFAULT_RETAIN_PROMPT = "List concrete details that must be preserved verbatim. Include tool output refs, file paths, identifiers, commands, TODOs, and any critical decisions.";
+var CompactionService = class _CompactionService {
+  config;
+  modelRegistry;
+  constructor(config, deps) {
+    this.config = _CompactionService.normalizeConfig(config);
+    this.modelRegistry = deps.modelRegistry;
+  }
+  async shouldCompact(llm, usage) {
+    if (!this.config.enabled) {
+      return false;
+    }
+    if (!this.config.auto) {
+      return false;
+    }
+    if (!usage) {
+      return false;
+    }
+    const contextLimit = await this.resolveContextLimit(llm, usage);
+    const threshold = Math.floor(contextLimit * this.config.thresholdRatio);
+    return usage.total_tokens >= threshold;
+  }
+  async compact(llm, messages, options) {
+    if (!this.config.enabled) {
+      return {
+        compacted: false,
+        compactedMessages: messages,
+        usage: null
+      };
+    }
+    const preparedMessages = this.prepareMessagesForSummary(messages);
+    const prompt = this.buildCompactionPrompt();
+    const interruptMessage = {
+      role: "user",
+      content: prompt
+    };
+    let response;
+    try {
+      response = await llm.ainvoke({
+        messages: [...preparedMessages, interruptMessage],
+        tools: null,
+        toolChoice: "none",
+        ...options?.signal ? { signal: options.signal } : {},
+        ...this.config.model ? { model: this.config.model } : {}
+      });
+    } catch (error) {
+      if (error instanceof Error && (error.name === "AbortError" || error.name === "APIUserAbortError" || error.name === "AbortSignal")) {
+        throw error;
+      }
+      return {
+        compacted: false,
+        compactedMessages: messages,
+        usage: null
+      };
+    }
+    const responseText = extractAssistantText(response.messages);
+    const parsed = this.parseCompactionResponse(responseText);
+    const summary = parsed.summary || parsed.fallbackSummary;
+    const retain = parsed.retain;
+    if (!summary && !retain) {
+      return {
+        compacted: false,
+        compactedMessages: messages,
+        usage: response.usage ?? null
+      };
+    }
+    const compactedMessages = this.buildCompactedMessages(
+      messages,
+      retain,
+      summary
+    );
+    return {
+      compacted: true,
+      compactedMessages,
+      usage: response.usage ?? null
+    };
+  }
+  prepareMessagesForSummary(messages) {
+    if (messages.length === 0) return messages;
+    const prepared = messages.map((message) => ({ ...message }));
+    const last = prepared[prepared.length - 1];
+    if (last.role === "assistant" && last.tool_calls?.length) {
+      if (last.content) {
+        const replacement = {
+          role: "assistant",
+          content: last.content,
+          name: last.name
+        };
+        prepared[prepared.length - 1] = replacement;
+      } else {
+        prepared.pop();
+      }
+    }
+    return prepared;
+  }
+  buildCompactionPrompt() {
+    const lines = [
+      "You are summarizing the conversation for context compaction.",
+      "Respond only with the XML-like tags below and nothing else:"
+    ];
+    if (this.config.retainPrompt !== null) {
+      lines.push("<retain>...</retain>");
+    }
+    lines.push("<summary>...</summary>", "");
+    if (this.config.retainPrompt !== null) {
+      lines.push("Retain instructions:", this.config.retainPrompt.trim());
+      lines.push(
+        ...this.config.retainDirectives.map((directive) => `- ${directive}`)
+      );
+      lines.push("");
+    }
+    lines.push("Summary instructions:", this.config.summaryPrompt.trim());
+    lines.push(
+      ...this.config.summaryDirectives.map((directive) => `- ${directive}`)
+    );
+    return lines.join("\n").trim();
+  }
+  parseCompactionResponse(text) {
+    const retain = this.config.retainPrompt === null ? "" : extractTag(text, "retain");
+    const summary = extractTag(text, "summary");
+    const fallbackSummary = text.replace(/<retain>[\s\S]*?<\/retain>/gi, "").replace(/<summary>|<\/summary>/gi, "").trim();
+    return {
+      retain: retain.trim(),
+      summary: summary.trim(),
+      fallbackSummary
+    };
+  }
+  buildCompactedMessages(messages, retain, summary) {
+    const systemMessages = [];
+    const nonSystemMessages = [];
+    for (const message of messages) {
+      if (message.role === "system") {
+        systemMessages.push(message);
+      } else {
+        nonSystemMessages.push(message);
+      }
+    }
+    const tail = this.getLastTurns(
+      nonSystemMessages,
+      this.config.retainLastTurns
+    );
+    const compacted = [...systemMessages];
+    if (retain) {
+      compacted.push({
+        role: "user",
+        content: retain
+      });
+    }
+    if (summary) {
+      compacted.push({
+        role: "user",
+        content: summary
+      });
+    }
+    compacted.push(...tail);
+    return compacted;
+  }
+  getLastTurns(messages, retainLastTurns) {
+    if (retainLastTurns <= 0) return [];
+    let remaining = retainLastTurns;
+    let startIndex = 0;
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+      if (messages[i].role === "user") {
+        remaining -= 1;
+        if (remaining === 0) {
+          startIndex = i;
+          break;
+        }
+      }
+    }
+    if (remaining > 0) {
+      startIndex = 0;
+    }
+    return messages.slice(startIndex);
+  }
+  async resolveContextLimit(llm, usage) {
+    const modelId = usage.model ?? llm.model;
+    const modelSpec = this.resolveModelSpecWithSnapshotFallback(
+      llm.provider,
+      modelId
+    );
+    if (modelSpec?.contextWindow && modelSpec.contextWindow > 0) {
+      return modelSpec.contextWindow;
+    }
+    if (modelSpec?.maxInputTokens && modelSpec.maxInputTokens > 0) {
+      return modelSpec.maxInputTokens;
+    }
+    throw new Error(
+      `Missing context limit for ${llm.provider}/${modelId} in model registry`
+    );
+  }
+  resolveModelSpecWithSnapshotFallback(provider, modelId) {
+    const direct = resolveModel(this.modelRegistry, modelId, provider);
+    if (direct) return direct;
+    const baseId = stripSnapshotSuffix(modelId);
+    if (!baseId || baseId === modelId) return void 0;
+    return resolveModel(this.modelRegistry, baseId, provider);
+  }
+  static normalizeConfig(config) {
+    const retainLastTurnsRaw = config.retainLastTurns ?? DEFAULT_RETAIN_LAST_TURNS;
+    return {
+      enabled: config.enabled ?? true,
+      auto: config.auto ?? true,
+      thresholdRatio: config.thresholdRatio ?? DEFAULT_THRESHOLD_RATIO,
+      model: config.model ?? null,
+      summaryPrompt: config.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT,
+      summaryDirectives: config.summaryDirectives ?? [],
+      retainPrompt: config.retainPrompt === void 0 ? DEFAULT_RETAIN_PROMPT : config.retainPrompt,
+      retainDirectives: config.retainDirectives ?? [],
+      retainLastTurns: Math.max(0, Math.floor(retainLastTurnsRaw))
+    };
+  }
+};
+var extractTag = (text, tag) => {
+  const regex = new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, "i");
+  const match = text.match(regex);
+  return match?.[1]?.trim() ?? "";
+};
+var stripSnapshotSuffix = (modelId) => modelId.replace(/-[0-9]{4}-[0-9]{2}-[0-9]{2}$/, "");
+var extractAssistantText = (messages) => messages.flatMap((message) => {
+  if (message.role !== "assistant" || message.content == null) {
+    return [];
+  }
+  if (typeof message.content === "string") {
+    return [message.content];
+  }
+  return [
+    message.content.map((part) => {
+      if (part.type === "text") return part.text;
+      if (part.type === "other") {
+        try {
+          return JSON.stringify(part.payload);
+        } catch {
+          return String(part.payload);
+        }
+      }
+      return "";
+    }).join("")
+  ];
+}).join("\n").trim();
+
+// src/services/tool-output-cache/service.ts
+var DEFAULT_MAX_MESSAGE_BYTES = 50 * 1024;
+var DEFAULT_CONTEXT_RATIO = 0.25;
+var MIN_CONTEXT_BUDGET = 2e4;
+var MAX_CONTEXT_BUDGET = 6e4;
+var APPROX_BYTES_PER_TOKEN = 4;
+var clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+var contentToText = (content) => {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    switch (part.type) {
+      case "text":
+        return part.text;
+      case "image_url":
+        return "[image]";
+      case "document":
+        return "[document]";
+      case "other":
+        return `[other:${part.provider}/${part.kind}]`;
+      default:
+        return "[content]";
+    }
+  }).join("");
+};
+var estimateTokens = (text) => Math.ceil(Buffer.byteLength(text, "utf8") / APPROX_BYTES_PER_TOKEN);
+var shouldBypassImmediateTruncation = (toolName) => toolName === "tool_output_cache" || toolName === "tool_output_cache_grep";
+var truncateForContext = (content, maxMessageBytes) => {
+  if (!content) return { output: "", truncated: false };
+  const lines = content.split(/\r?\n/);
+  const outputLines = [];
+  let bytes = 0;
+  let modified = false;
+  for (const line of lines) {
+    const size = Buffer.byteLength(line, "utf8") + (outputLines.length ? 1 : 0);
+    if (bytes + size > maxMessageBytes) {
+      modified = true;
+      break;
+    }
+    outputLines.push(line);
+    bytes += size;
+  }
+  return { output: outputLines.join("\n"), truncated: modified };
+};
+var ToolOutputCacheService = class {
+  config;
+  modelRegistry;
+  store;
+  constructor(config, deps) {
+    this.config = config;
+    this.modelRegistry = deps.modelRegistry;
+    this.store = deps.store;
+  }
+  async processToolMessage(message) {
+    if (this.config.enabled === false) return message;
+    const raw = contentToText(message.content);
+    const outputRef = await this.persistToolOutput(message, raw);
+    const truncated = shouldBypassImmediateTruncation(message.tool_name) ? { output: raw, truncated: false } : truncateForContext(
+      raw,
+      this.config.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES
+    );
+    const trimmed = truncated.truncated;
+    let output = truncated.output;
+    if (trimmed) {
+      const refLabel = outputRef?.id ? `; ref=${outputRef.id}` : "";
+      output += `
+
+[tool output truncated${refLabel}]`;
+    }
+    return {
+      ...message,
+      content: output,
+      output_ref: outputRef,
+      trimmed: trimmed || message.trimmed
+    };
+  }
+  async trimMessages(llm, messages) {
+    if (this.config.enabled === false) {
+      return { messages, trimmed: false };
+    }
+    const budget = await this.resolveContextBudgetTokens(llm);
+    let total = 0;
+    for (const message of messages) {
+      if (message.role !== "tool") continue;
+      total += estimateTokens(contentToText(message.content));
+    }
+    if (total <= budget) return { messages, trimmed: false };
+    const updated = messages.map((message) => ({ ...message }));
+    let trimmedAny = false;
+    for (const message of updated) {
+      if (message.role !== "tool") continue;
+      if (total <= budget) break;
+      const toolMessage = message;
+      const contentText = contentToText(toolMessage.content);
+      const refId = toolMessage.output_ref?.id ?? null;
+      const placeholder = refId ? `[tool output trimmed; ref=${refId}]` : "[tool output trimmed]";
+      const tokens = estimateTokens(contentText);
+      const placeholderTokens = estimateTokens(placeholder);
+      toolMessage.content = placeholder;
+      toolMessage.trimmed = true;
+      total = Math.max(0, total - tokens + placeholderTokens);
+      trimmedAny = true;
+    }
+    return { messages: updated, trimmed: trimmedAny };
+  }
+  async persistToolOutput(message, content) {
+    if (!this.store) return void 0;
+    try {
+      const result = await this.store.save({
+        tool_call_id: message.tool_call_id,
+        tool_name: message.tool_name,
+        content,
+        is_error: message.is_error
+      });
+      return result;
+    } catch {
+      return void 0;
+    }
+  }
+  async resolveContextBudgetTokens(llm) {
+    if (this.config.contextBudgetTokens !== void 0 && this.config.contextBudgetTokens !== null) {
+      return this.config.contextBudgetTokens;
+    }
+    const modelSpec = resolveModel(this.modelRegistry, llm.model, llm.provider);
+    const contextLimit = modelSpec?.contextWindow ?? modelSpec?.maxInputTokens ?? null;
+    if (!contextLimit || contextLimit <= 0) {
+      return MAX_CONTEXT_BUDGET;
+    }
+    const derived = Math.floor(contextLimit * DEFAULT_CONTEXT_RATIO);
+    return clamp(derived, MIN_CONTEXT_BUDGET, MAX_CONTEXT_BUDGET);
+  }
+};
+
+// src/services/usage/service.ts
+var TokenUsageService = class {
+  constructor(config) {
+    this.config = config;
+    this.usageSummary = {
+      total_calls: 0,
+      total_tokens: 0,
+      total_input_tokens: 0,
+      total_output_tokens: 0,
+      total_cached_input_tokens: 0,
+      total_cache_creation_tokens: 0,
+      total_cost_usd: 0,
+      by_model: {}
+    };
+  }
+  usageSummary;
+  lastUsage = null;
+  updateUsageSummary(usage) {
+    this.lastUsage = usage ?? null;
+    if (!this.config.enabled || !usage) {
+      return;
+    }
+    this.usageSummary.total_calls++;
+    this.usageSummary.total_tokens += usage.total_tokens;
+    this.usageSummary.total_input_tokens += usage.input_tokens;
+    this.usageSummary.total_output_tokens += usage.output_tokens;
+    this.usageSummary.total_cached_input_tokens += usage.input_cached_tokens ?? 0;
+    this.usageSummary.total_cache_creation_tokens += usage.input_cache_creation_tokens ?? 0;
+    const model = usage.model ?? "unknown";
+    if (!this.usageSummary.by_model[model]) {
+      this.usageSummary.by_model[model] = {
+        calls: 1,
+        input_tokens: usage.input_tokens,
+        output_tokens: usage.output_tokens,
+        cached_input_tokens: usage.input_cached_tokens ?? 0,
+        cache_creation_tokens: usage.input_cache_creation_tokens ?? 0,
+        total_tokens: usage.total_tokens
+      };
+    } else {
+      this.usageSummary.by_model[model].calls++;
+      this.usageSummary.by_model[model].input_tokens += usage.input_tokens;
+      this.usageSummary.by_model[model].output_tokens += usage.output_tokens;
+      this.usageSummary.by_model[model].cached_input_tokens += usage.input_cached_tokens ?? 0;
+      this.usageSummary.by_model[model].cache_creation_tokens += usage.input_cache_creation_tokens ?? 0;
+      this.usageSummary.by_model[model].total_tokens += usage.total_tokens;
+    }
+  }
+  getUsageSummary() {
+    return this.usageSummary;
+  }
+  getLastUsage() {
+    return this.lastUsage;
+  }
+};
+
+// src/tools/done.ts
+var TaskComplete = class extends Error {
+  finalMessage;
+  constructor(finalMessage) {
+    super("Task complete");
+    this.name = "TaskComplete";
+    this.finalMessage = finalMessage;
+  }
+};
+
+// src/agent/agent.ts
+var DEFAULT_MAX_ITERATIONS = 200;
+function toolResultToContent(result) {
+  if (result.type === "text") return result.text;
+  if (result.type === "parts") return result.parts;
+  try {
+    return JSON.stringify(result.value);
+  } catch {
+    return String(result.value);
+  }
+}
+var collectModelOutput = (messages) => {
+  const reasoningTexts = [];
+  const assistantTexts = [];
+  const toolCalls = [];
+  for (const message of messages) {
+    if (message.role === "reasoning") {
+      const text = message.content ?? "";
+      if (text) {
+        reasoningTexts.push(text);
+      }
+      continue;
+    }
+    if (message.role !== "assistant") {
+      continue;
+    }
+    if (message.content) {
+      const text = stringifyContent(message.content, { mode: "display" });
+      if (text) {
+        assistantTexts.push(text);
+      }
+    }
+    if (message.tool_calls?.length) {
+      toolCalls.push(...message.tool_calls);
+    }
+  }
+  return { reasoningTexts, assistantTexts, toolCalls };
+};
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+var createAbortError = () => {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+};
+var isAbortError = (error) => error instanceof Error && (error.name === "AbortError" || error.name === "APIUserAbortError" || error.name === "AbortSignal");
+var throwIfAborted = (signal) => {
+  if (signal?.aborted) {
+    throw createAbortError();
+  }
+};
+var Agent = class {
+  llm;
+  tools;
+  systemPrompt;
+  maxIterations;
+  toolChoice;
+  requireDoneTool;
+  compactionService;
+  toolOutputCacheService;
+  services;
+  modelRegistry;
+  canExecuteTool;
+  //private readonly dependencyOverrides?: DependencyOverrides;
+  history;
+  usageService;
+  constructor(options) {
+    this.llm = options.llm;
+    this.history = this.llm.provider === "openai" ? new OpenAIHistoryAdapter() : new MessageHistoryAdapter();
+    this.tools = options.tools;
+    this.systemPrompt = options.systemPrompt ?? void 0;
+    this.maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    this.toolChoice = options.toolChoice ?? void 0;
+    this.requireDoneTool = options.requireDoneTool ?? false;
+    this.services = options.services ?? {};
+    this.modelRegistry = options.modelRegistry ?? DEFAULT_MODEL_REGISTRY;
+    this.compactionService = options.compaction === null ? null : new CompactionService(options.compaction ?? {}, {
+      modelRegistry: this.modelRegistry
+    });
+    this.toolOutputCacheService = options.toolOutputCache === null ? null : new ToolOutputCacheService(options.toolOutputCache ?? {}, {
+      modelRegistry: this.modelRegistry,
+      store: this.services.toolOutputCacheStore ?? null
+    });
+    this.usageService = new TokenUsageService({
+      enabled: options.enableUsageTracking ?? true,
+      thresholdRatio: 0.5
+    });
+    this.canExecuteTool = options.canExecuteTool;
+  }
+  getUsageSummary() {
+    return this.usageService.getUsageSummary();
+  }
+  getContextLeftPercent() {
+    const usage = this.usageService.getLastUsage();
+    if (!usage) {
+      return null;
+    }
+    const modelId = usage.model ?? this.llm.model;
+    const modelSpec = resolveModel(
+      this.modelRegistry,
+      modelId,
+      this.llm.provider
+    );
+    const contextLimit = modelSpec?.contextWindow ?? modelSpec?.maxInputTokens ?? null;
+    if (!contextLimit || contextLimit <= 0) {
+      return null;
+    }
+    const used = usage.total_tokens;
+    if (!Number.isFinite(used) || used <= 0) {
+      return 100;
+    }
+    const leftRatio = 1 - used / contextLimit;
+    const percent = Math.round(leftRatio * 100);
+    return Math.max(0, Math.min(100, percent));
+  }
+  getHistoryMessages() {
+    return this.history.getViewMessages();
+  }
+  replaceHistoryMessages(messages) {
+    this.history.replaceViewMessages(messages);
+  }
+  async *checkAndCompact(signal, options = {}) {
+    throwIfAborted(signal);
+    await this.trimToolOutputs();
+    const shouldCompact = options.force ? true : await this.compactionService?.shouldCompact(
+      this.llm,
+      this.usageService.getLastUsage()
+    );
+    if (shouldCompact && this.compactionService) {
+      throwIfAborted(signal);
+      const startEvent = {
+        type: "compaction_start",
+        timestamp: Date.now()
+      };
+      yield startEvent;
+      const { compacted, compactedMessages, usage } = await this.compactionService.compact(
+        this.llm,
+        this.history.getViewMessages(),
+        { signal }
+      );
+      this.usageService.updateUsageSummary(usage);
+      if (compacted && compactedMessages) {
+        this.history.replaceViewMessages(compactedMessages);
+      }
+      const completeEvent = {
+        type: "compaction_complete",
+        timestamp: Date.now(),
+        compacted
+      };
+      yield completeEvent;
+    }
+  }
+  async trimToolOutputs() {
+    if (!this.toolOutputCacheService) return;
+    const { messages, trimmed } = await this.toolOutputCacheService.trimMessages(
+      this.llm,
+      this.history.getViewMessages()
+    );
+    if (trimmed) {
+      this.history.replaceViewMessages(messages);
+    }
+  }
+  async processToolMessage(message) {
+    if (!this.toolOutputCacheService) return message;
+    return this.toolOutputCacheService.processToolMessage(message);
+  }
+  buildToolContext(signal) {
+    const deps = /* @__PURE__ */ Object.create(null);
+    const cache = /* @__PURE__ */ new Map();
+    const resolve = async (key) => {
+      if (cache.has(key.id)) {
+        return cache.get(key.id);
+      }
+      const value = await key.create();
+      cache.set(key.id, value);
+      return value;
+    };
+    return {
+      deps,
+      resolve,
+      signal,
+      now: () => /* @__PURE__ */ new Date()
+    };
+  }
+  recordLlmRequest(session, input) {
+    if (!session) return null;
+    const seq = (session.invoke_seq ?? 0) + 1;
+    session.invoke_seq = seq;
+    const modelName = input.model ?? this.llm.model;
+    session.append({
+      type: "llm.request",
+      run_id: session.run_id,
+      ts: nowIso(),
+      seq,
+      model: {
+        provider: this.llm.provider,
+        name: modelName
+      },
+      input: {
+        messages: input.messages,
+        tools: input.tools ?? null,
+        tool_choice: input.toolChoice ?? null,
+        model: input.model
+      }
+    });
+    return seq;
+  }
+  recordLlmResponse(session, seq, response) {
+    if (!session || seq === null) return;
+    session.append({
+      type: "llm.response",
+      run_id: session.run_id,
+      ts: nowIso(),
+      seq,
+      output: {
+        messages: response.messages,
+        usage: response.usage ?? null,
+        stop_reason: response.stop_reason ?? null,
+        provider_meta: response.provider_meta ?? null
+      }
+    });
+  }
+  async run(message, options = {}) {
+    let finalResponse = "";
+    for await (const event of this.runStream(message, options)) {
+      if (event.type === "final") {
+        finalResponse = event.content;
+        break;
+      }
+    }
+    return finalResponse;
+  }
+  async *runStream(message, options = {}) {
+    const session = options.session;
+    const signal = options.signal;
+    const forceCompaction = options.forceCompaction ?? false;
+    if (this.systemPrompt) {
+      const systemMessage = {
+        role: "system",
+        content: this.systemPrompt
+      };
+      this.history.enqueueSystem(systemMessage);
+    }
+    if (forceCompaction) {
+      yield* this.checkAndCompact(signal, { force: true });
+      const finalResponseEvent2 = {
+        type: "final",
+        content: "Compaction run completed."
+      };
+      yield finalResponseEvent2;
+      return;
+    }
+    this.history.enqueueUserMessage(message);
+    let iterations = 0;
+    while (iterations < this.maxIterations) {
+      iterations++;
+      throwIfAborted(signal);
+      await this.trimToolOutputs();
+      throwIfAborted(signal);
+      const invokeInput = this.history.prepareInvokeInput({
+        tools: this.tools.map((t) => t.definition),
+        toolChoice: this.toolChoice
+      });
+      const seq = this.recordLlmRequest(session, invokeInput);
+      const response = await this.llm.ainvoke({
+        ...invokeInput,
+        ...signal ? { signal } : {}
+      });
+      this.recordLlmResponse(session, seq, response);
+      this.usageService.updateUsageSummary(response.usage);
+      this.history.commitModelResponse(response);
+      const { reasoningTexts, assistantTexts, toolCalls } = collectModelOutput(
+        response.messages
+      );
+      for (const reasoningText of reasoningTexts) {
+        const reasoningEvent = {
+          type: "reasoning",
+          content: reasoningText,
+          timestamp: Date.now()
+        };
+        yield reasoningEvent;
+      }
+      const hasToolCalls = toolCalls.length > 0;
+      const shouldEmitFinalOnly = !hasToolCalls && !this.requireDoneTool;
+      if (!shouldEmitFinalOnly) {
+        for (const assistantText of assistantTexts) {
+          const textEvent = {
+            type: "text",
+            content: assistantText,
+            timestamp: Date.now()
+          };
+          yield textEvent;
+        }
+      }
+      if (!hasToolCalls) {
+        if (!this.requireDoneTool) {
+          yield* this.checkAndCompact(signal);
+          const finalText = assistantTexts.join("\n").trim();
+          const finalResponseEvent2 = {
+            type: "final",
+            content: finalText
+          };
+          yield finalResponseEvent2;
+          return;
+        } else {
+          yield* this.checkAndCompact(signal);
+        }
+        continue;
+      }
+      let stepNumber = 0;
+      for (const toolCall of toolCalls) {
+        stepNumber++;
+        let jsonArgs;
+        try {
+          jsonArgs = JSON.parse(toolCall.function.arguments);
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            jsonArgs = { _raw: toolCall.function.arguments };
+          } else {
+            throw e;
+          }
+        }
+        const stepStartEvent = {
+          type: "step_start",
+          step_id: toolCall.id,
+          title: toolCall.function.name,
+          step_number: stepNumber
+        };
+        yield stepStartEvent;
+        const toolCallEvent = {
+          type: "tool_call",
+          tool: toolCall.function.name,
+          args: jsonArgs,
+          tool_call_id: toolCall.id
+        };
+        yield toolCallEvent;
+        const startTime = Date.now();
+        try {
+          throwIfAborted(signal);
+          const execution = await this.executeToolCall(toolCall, signal);
+          const rawOutput = stringifyContent(execution.message.content, {
+            mode: "display"
+          });
+          const processedMessage = await this.processToolMessage(
+            execution.message
+          );
+          if (session) {
+            session.append({
+              type: "tool.output",
+              run_id: session.run_id,
+              ts: nowIso(),
+              tool: toolCall.function.name,
+              tool_call_id: toolCall.id,
+              result_raw: rawOutput,
+              is_error: processedMessage.is_error,
+              output_ref: processedMessage.output_ref
+            });
+          }
+          this.history.enqueueToolResult(processedMessage);
+          const toolResultEvent = {
+            type: "tool_result",
+            tool: toolCall.function.name,
+            result: stringifyContent(processedMessage.content, {
+              mode: "display"
+            }),
+            tool_call_id: toolCall.id,
+            is_error: processedMessage.is_error
+          };
+          yield toolResultEvent;
+          const durationMs = Date.now() - startTime;
+          const stepCompleteEvent = {
+            type: "step_complete",
+            step_id: toolCall.id,
+            status: execution.message.is_error ? "error" : "completed",
+            duration_ms: durationMs
+          };
+          yield stepCompleteEvent;
+          if (execution.done) {
+            const finalResponseEvent2 = {
+              type: "final",
+              content: execution.finalMessage ?? assistantTexts.join("\n").trim()
+            };
+            yield finalResponseEvent2;
+            return;
+          }
+        } catch (error) {
+          if (isAbortError(error)) {
+            throw error;
+          }
+          const content = `Error: ${error instanceof Error ? error.message : String(error)}`;
+          const errorToolMessage = {
+            role: "tool",
+            tool_call_id: toolCall.id,
+            tool_name: toolCall.function.name,
+            content,
+            is_error: true
+          };
+          const processedMessage = await this.processToolMessage(errorToolMessage);
+          const rawOutput = stringifyContent(errorToolMessage.content, {
+            mode: "display"
+          });
+          if (session) {
+            session.append({
+              type: "tool.output",
+              run_id: session.run_id,
+              ts: nowIso(),
+              tool: toolCall.function.name,
+              tool_call_id: toolCall.id,
+              result_raw: rawOutput,
+              is_error: true,
+              output_ref: processedMessage.output_ref
+            });
+          }
+          this.history.enqueueToolResult(processedMessage);
+          const toolResultEvent = {
+            type: "tool_result",
+            tool: toolCall.function.name,
+            result: stringifyContent(processedMessage.content, {
+              mode: "display"
+            }),
+            tool_call_id: toolCall.id,
+            is_error: true
+          };
+          yield toolResultEvent;
+          const durationMs = Date.now() - startTime;
+          const stepCompleteEvent = {
+            type: "step_complete",
+            step_id: toolCall.id,
+            status: "error",
+            duration_ms: durationMs
+          };
+          yield stepCompleteEvent;
+        }
+      }
+      yield* this.checkAndCompact(signal);
+    }
+    const finalResponse = await this.generateFinalResponse(session, signal);
+    const finalResponseEvent = {
+      type: "final",
+      content: finalResponse
+    };
+    yield finalResponseEvent;
+    return;
+  }
+  async generateFinalResponse(session, signal) {
+    const summaryMessage = {
+      role: "user",
+      content: `You are generating the final response for the user after the agent reached max iterations. Summarize what was completed, what is pending, and any blockers. Be concise, user-facing, and do not mention internal agent mechanics. If there is a clear next step, suggest it as a short list.`
+    };
+    try {
+      const input = {
+        messages: [...this.history.getViewMessages(), summaryMessage],
+        // temporal messages for summary
+        tools: null,
+        // no tools are allowed at this point
+        toolChoice: "none"
+      };
+      const seq = this.recordLlmRequest(session, input);
+      const summary = await this.llm.ainvoke({
+        ...input,
+        ...signal ? { signal } : {}
+      });
+      this.recordLlmResponse(session, seq, summary);
+      this.usageService.updateUsageSummary(summary.usage);
+      const { assistantTexts } = collectModelOutput(summary.messages);
+      const finalResponse = `[Max Iterations Reached]
+
+${assistantTexts.join("\n").trim()}`;
+      return finalResponse;
+    } catch {
+      if (signal?.aborted) {
+        throw createAbortError();
+      }
+      return "[Max Iterations Reached]\n\nSummary unavailable due to an internal error.";
+    }
+  }
+  async executeToolCall(toolCall, signal) {
+    const toolName = toolCall.function.name;
+    const tool = this.tools.find((t) => t.name === toolName);
+    if (!tool) {
+      return {
+        message: {
+          role: "tool",
+          tool_call_id: toolCall.id,
+          tool_name: toolName,
+          content: `Error: Unknown tool '${toolName}'`,
+          is_error: true
+        }
+      };
+    }
+    if (this.canExecuteTool) {
+      try {
+        const decision = await this.canExecuteTool(
+          toolCall,
+          toolCall.function.arguments,
+          this.buildToolContext(signal)
+        );
+        if (decision.decision === "deny") {
+          const deniedContent = `Permission denied${decision.reason ? `: ${decision.reason}` : ""}`;
+          return {
+            message: {
+              role: "tool",
+              tool_call_id: toolCall.id,
+              tool_name: toolName,
+              content: deniedContent,
+              is_error: true
+            },
+            ...decision.stop_turn ? {
+              done: true,
+              finalMessage: "Permission request was denied. Turn stopped. Please send your next input to continue."
+            } : {}
+          };
+        }
+      } catch (error) {
+        return {
+          message: {
+            role: "tool",
+            tool_call_id: toolCall.id,
+            tool_name: toolName,
+            content: `Permission check failed: ${error instanceof Error ? error.message : String(error)}`,
+            is_error: true
+          }
+        };
+      }
+    }
+    try {
+      const result = await tool.executeRaw(
+        toolCall.function.arguments,
+        this.buildToolContext(signal)
+      );
+      return {
+        message: {
+          role: "tool",
+          tool_call_id: toolCall.id,
+          tool_name: toolName,
+          content: toolResultToContent(result)
+        }
+      };
+    } catch (error) {
+      if (error instanceof TaskComplete) {
+        return {
+          message: {
+            role: "tool",
+            tool_call_id: toolCall.id,
+            tool_name: toolName,
+            content: "Task complete"
+          },
+          done: true,
+          finalMessage: error.finalMessage
+        };
+      }
+      return {
+        message: {
+          role: "tool",
+          tool_call_id: toolCall.id,
+          tool_name: toolName,
+          content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+          is_error: true
+        }
+      };
+    }
+  }
+};
+
+// src/llm/anthropic/chat.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/llm/anthropic/serializer.ts
+var isRecord = (value) => typeof value === "object" && value !== null;
+var stringifyUnknown2 = (value) => {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var formatOtherPart = (part) => {
+  const payloadText = stringifyUnknown2(part.payload);
+  return payloadText ? `[other:${part.provider}/${part.kind}] ${payloadText}` : `[other:${part.provider}/${part.kind}]`;
+};
+var parseDataUrl = (url) => {
+  const match = /^data:([^;]+);base64,(.+)$/.exec(url);
+  if (!match) return null;
+  return { mediaType: match[1], data: match[2] };
+};
+var isSupportedImageMediaType = (value) => value === "image/png" || value === "image/jpeg" || value === "image/webp" || value === "image/gif";
+var isAnthropicContentBlock = (value) => {
+  if (!isRecord(value) || typeof value.type !== "string") return false;
+  switch (value.type) {
+    case "text":
+      return typeof value.text === "string";
+    case "image":
+      return isRecord(value.source);
+    case "document":
+      return isRecord(value.source);
+    case "search_result":
+      return true;
+    default:
+      return false;
+  }
+};
+var contentPartsToText = (content) => {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    switch (part.type) {
+      case "text":
+        return part.text;
+      case "image_url":
+        return "[image]";
+      case "document":
+        return "[document]";
+      case "other":
+        return `[other:${part.provider}/${part.kind}]`;
+      default:
+        return "[content]";
+    }
+  }).join("");
+};
+var toTextBlock = (text) => ({
+  type: "text",
+  text
+});
+var toContentBlocks = (content) => {
+  if (content == null) return [];
+  if (typeof content === "string") {
+    return content ? [toTextBlock(content)] : [];
+  }
+  return content.map((part) => {
+    switch (part.type) {
+      case "text":
+        return toTextBlock(part.text);
+      case "image_url": {
+        const dataUrl = parseDataUrl(part.image_url.url);
+        if (dataUrl) {
+          const mediaType = part.image_url.media_type ?? (isSupportedImageMediaType(dataUrl.mediaType) ? dataUrl.mediaType : void 0);
+          if (!mediaType) {
+            return toTextBlock(part.image_url.url);
+          }
+          return {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: mediaType,
+              data: dataUrl.data
+            }
+          };
+        }
+        return toTextBlock(part.image_url.url);
+      }
+      case "document":
+        return toTextBlock("[document]");
+      case "other":
+        if (part.provider === "anthropic" && isAnthropicContentBlock(part.payload)) {
+          return part.payload;
+        }
+        return toTextBlock(formatOtherPart(part));
+      default:
+        return toTextBlock("");
+    }
+  });
+};
+var ensureToolResultBlocks = (blocks) => blocks.length > 0 ? blocks : [toTextBlock("")];
+var ensureMessageBlocks = (blocks) => blocks.length > 0 ? blocks : [toTextBlock("")];
+var toToolUseBlock = (call) => {
+  let input = call.function.arguments;
+  if (call.function.arguments) {
+    try {
+      input = JSON.parse(call.function.arguments);
+    } catch {
+      input = { value: call.function.arguments };
+    }
+  }
+  return {
+    type: "tool_use",
+    id: call.id,
+    name: call.function.name,
+    input
+  };
+};
+var toToolResultBlock = (message) => {
+  const content = typeof message.content === "string" ? message.content : ensureToolResultBlocks(toContentBlocks(message.content));
+  return {
+    type: "tool_result",
+    tool_use_id: message.tool_call_id,
+    content,
+    ...message.is_error ? { is_error: true } : {}
+  };
+};
+var toAnthropicTools = (tools) => {
+  if (!tools || tools.length === 0) return void 0;
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.parameters
+  }));
+};
+var toAnthropicToolChoice = (choice) => {
+  if (!choice) return void 0;
+  if (choice === "auto") return { type: "auto" };
+  if (choice === "required") return { type: "any" };
+  if (choice === "none") return void 0;
+  return { type: "tool", name: choice };
+};
+var toAnthropicMessages = (messages) => {
+  const systemParts = [];
+  const output = [];
+  for (const message of messages) {
+    switch (message.role) {
+      case "system": {
+        const text = contentPartsToText(message.content);
+        if (text) systemParts.push(text);
+        break;
+      }
+      case "reasoning":
+        break;
+      case "tool": {
+        output.push({
+          role: "user",
+          content: [toToolResultBlock(message)]
+        });
+        break;
+      }
+      case "assistant": {
+        const blocks = [];
+        blocks.push(...toContentBlocks(message.content));
+        if (message.tool_calls?.length) {
+          blocks.push(...message.tool_calls.map(toToolUseBlock));
+        }
+        output.push({
+          role: "assistant",
+          content: ensureMessageBlocks(blocks)
+        });
+        break;
+      }
+      case "user": {
+        const blocks = ensureToolResultBlocks(toContentBlocks(message.content));
+        output.push({
+          role: "user",
+          content: blocks
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const system = systemParts.length ? systemParts.join("\n\n") : void 0;
+  return { system, messages: output };
+};
+var extractText = (blocks) => blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+var toUsage = (response) => {
+  if (!response.usage) return null;
+  const inputTokens = response.usage.input_tokens ?? 0;
+  const outputTokens = response.usage.output_tokens ?? 0;
+  return {
+    model: response.model ?? "",
+    input_tokens: inputTokens,
+    input_cached_tokens: response.usage.cache_read_input_tokens ?? null,
+    input_cache_creation_tokens: response.usage.cache_creation_input_tokens ?? null,
+    output_tokens: outputTokens,
+    total_tokens: inputTokens + outputTokens
+  };
+};
+var toChatInvokeCompletion = (response) => {
+  const blocks = response.content ?? [];
+  const messages = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        messages.push({
+          role: "assistant",
+          content: block.text
+        });
+        break;
+      case "tool_use":
+        messages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: [
+            {
+              id: block.id,
+              type: "function",
+              function: {
+                name: block.name,
+                arguments: isRecord(block.input) ? JSON.stringify(block.input) : JSON.stringify({ value: block.input })
+              },
+              provider_meta: block
+            }
+          ]
+        });
+        break;
+      case "thinking":
+        messages.push({
+          role: "reasoning",
+          content: block.thinking,
+          raw_item: block
+        });
+        break;
+      case "redacted_thinking":
+        messages.push({
+          role: "reasoning",
+          content: "[redacted]",
+          raw_item: block
+        });
+        break;
+      default:
+        messages.push({
+          role: "assistant",
+          content: [
+            {
+              type: "other",
+              provider: "anthropic",
+              kind: block.type,
+              payload: block
+            }
+          ]
+        });
+        break;
+    }
+  }
+  if (messages.length === 0) {
+    const fallback = extractText(blocks);
+    if (fallback) {
+      messages.push({ role: "assistant", content: fallback });
+    }
+  }
+  return {
+    messages,
+    usage: toUsage(response),
+    stop_reason: response.stop_reason ?? response.stop_sequence ?? null,
+    provider_meta: {
+      response_id: response.id,
+      model: response.model,
+      raw_output_text: stringifyUnknown2(extractText(blocks))
+    }
+  };
+};
+
+// src/llm/anthropic/chat.ts
+var PROVIDER_NAME = "anthropic";
+var DEFAULT_MODEL = ANTHROPIC_DEFAULT_MODEL;
+var DEFAULT_MAX_TOKENS = 4096;
+var ChatAnthropic = class {
+  provider = PROVIDER_NAME;
+  model;
+  client;
+  defaultMaxTokens;
+  constructor(options = {}) {
+    this.client = options.client ?? new Anthropic(options.clientOptions);
+    this.model = options.model ?? DEFAULT_MODEL;
+    this.defaultMaxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
+  }
+  async ainvoke(input, verbose = false) {
+    const {
+      messages,
+      tools: toolDefs,
+      toolChoice,
+      options,
+      model,
+      signal
+    } = input;
+    const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
+    const enableTools = toolChoice !== "none";
+    const tools = enableTools ? toAnthropicTools(toolDefs) : void 0;
+    const tool_choice = enableTools ? toAnthropicToolChoice(toolChoice) : void 0;
+    const { max_tokens, ...rest } = options ?? {};
+    const request = {
+      model: model ?? this.model,
+      max_tokens: max_tokens ?? this.defaultMaxTokens,
+      messages: anthropicMessages,
+      ...rest,
+      ...system ? { system } : {},
+      ...tools ? { tools } : {},
+      ...tool_choice ? { tool_choice } : {}
+    };
+    if (verbose) {
+      console.debug(request);
+    }
+    const response = await this.client.messages.create(
+      request,
+      signal ? {
+        signal
+      } : void 0
+    );
+    if (verbose) {
+      console.debug(response);
+    }
+    return toChatInvokeCompletion(response);
+  }
+};
+
+// src/llm/openai/chat.ts
+import OpenAI from "openai";
+
+// src/llm/openai/response-utils.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var stringifyUnknown3 = (value) => {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var formatOtherPart2 = (part) => {
+  const payloadText = stringifyUnknown3(part.payload);
+  return payloadText ? `[other:${part.provider}/${part.kind}] ${payloadText}` : `[other:${part.provider}/${part.kind}]`;
+};
+var isOpenAiInputContent = (value) => {
+  if (!isRecord2(value)) return false;
+  const type = value.type;
+  if (type === "input_text") {
+    return typeof value.text === "string";
+  }
+  if (type === "input_image") {
+    return typeof value.image_url === "string";
+  }
+  if (type === "input_file") {
+    return typeof value.file_data === "string" || typeof value.file_id === "string";
+  }
+  return false;
+};
+var extractOutputText = (items) => {
+  const texts = [];
+  for (const item of items) {
+    if (item.type !== "message") continue;
+    for (const part of item.content ?? []) {
+      if (part.type === "output_text") {
+        texts.push(part.text);
+      }
+    }
+  }
+  return texts.join("");
+};
+var toResponseInputContent = (part) => {
+  switch (part.type) {
+    case "text":
+      return { type: "input_text", text: part.text };
+    case "image_url":
+      return {
+        type: "input_image",
+        image_url: part.image_url.url,
+        detail: part.image_url.detail ?? "auto"
+      };
+    case "document":
+      return {
+        type: "input_file",
+        file_data: part.source.data,
+        filename: "document.pdf"
+      };
+    case "other":
+      if (part.provider === "openai" && isOpenAiInputContent(part.payload)) {
+        return part.payload;
+      }
+      return { type: "input_text", text: formatOtherPart2(part) };
+    default:
+      return { type: "input_text", text: "" };
+  }
+};
+var toResponseInputContents = (content) => {
+  if (content == null) {
+    return "";
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(toResponseInputContent);
+};
+var toFunctionCallOutput = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map(toResponseInputContent);
+};
+
+// src/llm/openai/serializer.ts
+var toOpenAiOtherPart = (kind, payload) => ({
+  type: "other",
+  provider: "openai",
+  kind,
+  payload
+});
+var toAssistantOutputMessageContent = (item) => {
+  const contents = item.content ?? [];
+  if (contents.length === 0) {
+    return null;
+  }
+  const parts = contents.map((part) => {
+    if (part.type === "output_text") {
+      return { type: "text", text: part.text };
+    }
+    return toOpenAiOtherPart(part.type, part);
+  });
+  return parts;
+};
+var stringifyUnknown4 = (value) => {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var formatOtherPart3 = (part) => {
+  const payloadText = stringifyUnknown4(part.payload);
+  return payloadText ? `[other:${part.provider}/${part.kind}] ${payloadText}` : `[other:${part.provider}/${part.kind}]`;
+};
+var isOpenAIAssistantInputContent = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (record.type === "output_text") {
+    return typeof record.text === "string";
+  }
+  if (record.type === "refusal") {
+    return typeof record.refusal === "string";
+  }
+  return false;
+};
+var toAssistantInputContent = (part) => {
+  switch (part.type) {
+    case "text":
+      return { type: "output_text", text: part.text };
+    case "other":
+      if (part.provider === "openai" && isOpenAIAssistantInputContent(part.payload)) {
+        return part.payload;
+      }
+      return { type: "output_text", text: formatOtherPart3(part) };
+    case "image_url":
+      return { type: "output_text", text: "[image]" };
+    case "document":
+      return { type: "output_text", text: "[document]" };
+    default:
+      return { type: "output_text", text: "" };
+  }
+};
+var toAssistantInputMessageContent = (content, refusal) => {
+  const parts = [];
+  if (typeof content === "string") {
+    if (content) {
+      parts.push({ type: "output_text", text: content });
+    }
+  } else if (Array.isArray(content)) {
+    parts.push(...content.map(toAssistantInputContent));
+  }
+  if (refusal) {
+    parts.push({ type: "refusal", refusal });
+  }
+  return parts;
+};
+var extractReasoningText = (item) => {
+  const summaryText = (item.summary ?? []).map(
+    (part) => part && typeof part === "object" && "text" in part ? String(part.text ?? "") : ""
+  ).filter((text) => text.length > 0).join("\n");
+  if (summaryText) return summaryText;
+  const contentText = (item.content ?? []).map(
+    (part) => part && typeof part === "object" && "text" in part ? String(part.text ?? "") : ""
+  ).filter((text) => text.length > 0).join("\n");
+  return contentText;
+};
+var toMessageSequence = (response) => {
+  const messages = [];
+  for (const item of response.output) {
+    switch (item.type) {
+      case "reasoning": {
+        messages.push({
+          role: "reasoning",
+          content: extractReasoningText(item),
+          raw_item: item
+        });
+        break;
+      }
+      case "function_call": {
+        const toolCall = {
+          id: item.call_id,
+          type: "function",
+          function: { name: item.name, arguments: item.arguments },
+          provider_meta: item
+        };
+        messages.push({
+          role: "assistant",
+          content: null,
+          tool_calls: [toolCall]
+        });
+        break;
+      }
+      case "message": {
+        messages.push({
+          role: "assistant",
+          content: toAssistantOutputMessageContent(item)
+        });
+        break;
+      }
+      default: {
+        messages.push({
+          role: "assistant",
+          content: [toOpenAiOtherPart(item.type, item)]
+        });
+        break;
+      }
+    }
+  }
+  return messages;
+};
+function extractInstructions(messages) {
+  const chunks = [];
+  for (const message of messages) {
+    if (message.role !== "system") {
+      continue;
+    }
+    const content = message.content;
+    if (content == null) {
+      continue;
+    }
+    if (typeof content === "string") {
+      const trimmed = content.trim();
+      if (trimmed) {
+        chunks.push(trimmed);
+      }
+      continue;
+    }
+    const text = content.map((part) => {
+      switch (part.type) {
+        case "text":
+          return part.text;
+        default:
+          return "";
+      }
+    }).join("").trim();
+    if (text) {
+      chunks.push(text);
+    }
+  }
+  return chunks.length ? chunks.join("\n\n") : void 0;
+}
+function toResponsesInput(messages) {
+  const items = [];
+  for (const message of messages) {
+    if (message.role === "system") {
+      continue;
+    }
+    if (message.role === "tool") {
+      items.push(toFunctionCallOutputItem(message));
+      continue;
+    }
+    if (message.role === "assistant" && message.tool_calls?.length) {
+      const assistantMessageItem = toAssistantMessageItem(message);
+      if (assistantMessageItem) {
+        items.push(assistantMessageItem);
+      }
+      for (const call of message.tool_calls) {
+        items.push(toFunctionCallItem(call));
+      }
+      continue;
+    }
+    if (message.role === "reasoning") {
+      continue;
+    }
+    if (message.role === "assistant") {
+      const assistantMessageItem = toAssistantMessageItem(message);
+      if (assistantMessageItem) {
+        items.push(assistantMessageItem);
+      }
+      continue;
+    }
+    items.push({
+      type: "message",
+      role: message.role,
+      content: toUserMessageContent(message.content)
+    });
+  }
+  return items;
+}
+function toResponsesTools(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+    strict: tool.strict ?? false
+  }));
+}
+function toResponsesToolChoice(choice) {
+  if (!choice) {
+    return void 0;
+  }
+  if (choice === "auto" || choice === "required" || choice === "none") {
+    return choice;
+  }
+  return { type: "function", name: choice };
+}
+function toChatInvokeCompletion2(response) {
+  const usage = response.usage ? {
+    model: response.model,
+    input_tokens: response.usage.input_tokens,
+    input_cached_tokens: response.usage.input_tokens_details?.cached_tokens,
+    output_tokens: response.usage.output_tokens,
+    total_tokens: response.usage.total_tokens
+  } : null;
+  const messages = toMessageSequence(response);
+  if (!messages.length) {
+    const fallbackText = typeof response.output_text === "string" ? response.output_text : extractOutputText(response.output);
+    if (fallbackText) {
+      messages.push({ role: "assistant", content: fallbackText });
+    }
+  }
+  return {
+    messages,
+    usage,
+    stop_reason: response.incomplete_details?.reason ?? response.status ?? null,
+    provider_meta: {
+      response_id: response.id
+    }
+  };
+}
+function toUserMessageContent(content) {
+  return toResponseInputContents(content);
+}
+function toAssistantMessageItem(message) {
+  const content = toAssistantInputMessageContent(
+    message.content,
+    message.refusal
+  );
+  if (content.length === 0) {
+    return null;
+  }
+  return {
+    type: "message",
+    role: "assistant",
+    content
+  };
+}
+function toFunctionCallItem(call) {
+  return {
+    type: "function_call",
+    call_id: call.id,
+    name: call.function.name,
+    arguments: call.function.arguments
+  };
+}
+function toFunctionCallOutputItem(message) {
+  return {
+    type: "function_call_output",
+    call_id: message.tool_call_id,
+    output: toFunctionCallOutput(message.content)
+  };
+}
+
+// src/llm/openai/chat.ts
+var PROVIDER_NAME2 = "openai";
+var DEFAULT_MODEL2 = OPENAI_DEFAULT_MODEL;
+var DEFAULT_REASONING_EFFORT = OPENAI_DEFAULT_REASONING_EFFORT;
+var DEFAULT_REASONING_SUMMARY = "auto";
+var ChatOpenAI = class {
+  provider = PROVIDER_NAME2;
+  model;
+  client;
+  defaultReasoningEffort;
+  defaultTextVerbosity;
+  constructor(options = {}) {
+    this.client = options.client ?? new OpenAI(options.clientOptions);
+    this.model = options.model ?? DEFAULT_MODEL2;
+    this.defaultReasoningEffort = options.reasoningEffort ?? DEFAULT_REASONING_EFFORT;
+    this.defaultTextVerbosity = options.textVerbosity;
+  }
+  async ainvoke(input, verbose = false) {
+    const {
+      messages,
+      tools: toolDefs,
+      toolChoice,
+      options,
+      model,
+      signal
+    } = input;
+    const inputItems = toResponsesInput(messages);
+    const instructions = extractInstructions(messages);
+    const tools = toResponsesTools(toolDefs);
+    const tool_choice = toResponsesToolChoice(toolChoice);
+    const { reasoningEffort, textVerbosity, ...rest } = options ?? {};
+    const request = {
+      model: model ?? this.model,
+      input: inputItems,
+      ...rest,
+      ...tools ? { tools } : {},
+      ...tool_choice ? { tool_choice } : {}
+    };
+    if (request.store === void 0) {
+      request.store = false;
+    }
+    if (instructions) {
+      request.instructions = instructions;
+    }
+    request.include = ["reasoning.encrypted_content"];
+    const effort = reasoningEffort ?? this.defaultReasoningEffort;
+    request.reasoning = { effort, summary: DEFAULT_REASONING_SUMMARY };
+    const verbosity = textVerbosity ?? this.defaultTextVerbosity;
+    if (verbosity) {
+      request.text = {
+        ...request.text ?? {},
+        verbosity
+      };
+    }
+    if (verbose) {
+      console.debug(request);
+    }
+    const streamRequest = {
+      ...request,
+      stream: true
+    };
+    const response = await this.client.responses.stream(
+      streamRequest,
+      signal ? {
+        signal
+      } : void 0
+    ).finalResponse();
+    if (verbose) {
+      console.debug(response);
+    }
+    return toChatInvokeCompletion2(response);
+  }
+};
+
+// src/prompts.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var resolvePromptPath = () => {
+  if (typeof __filename === "string") {
+    return path.resolve(path.dirname(__filename), "../prompts/system.md");
+  }
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    return fileURLToPath(new URL("../prompts/system.md", import.meta.url));
+  }
+  return path.resolve("prompts/system.md");
+};
+var promptPath = resolvePromptPath();
+var getDefaultSystemPromptPath = () => promptPath;
+
+// src/tools/define.ts
+import { toJSONSchema } from "zod";
+
+// src/types/llm/guards.ts
+var TOOL_RESULT_TYPES = /* @__PURE__ */ new Set(["text", "parts", "json"]);
+function isTextPart(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === "text" && typeof v.text === "string";
+}
+function isImagePart(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.type !== "image_url") return false;
+  if (!v.image_url || typeof v.image_url !== "object") return false;
+  const url = v.image_url.url;
+  return typeof url === "string";
+}
+function isDocumentPart(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.type !== "document") return false;
+  if (!v.source || typeof v.source !== "object") return false;
+  const source = v.source;
+  return typeof source.data === "string" && source.media_type === "application/pdf";
+}
+function isOtherPart(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === "other" && typeof v.provider === "string" && typeof v.kind === "string";
+}
+function isContentPart(value) {
+  return isTextPart(value) || isImagePart(value) || isDocumentPart(value) || isOtherPart(value);
+}
+function isToolResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (!TOOL_RESULT_TYPES.has(String(v.type))) return false;
+  if (v.type === "text")
+    return typeof value.text === "string";
+  if (v.type === "json") return "value" in value;
+  if (v.type === "parts") {
+    const parts = value.parts;
+    return Array.isArray(parts) && parts.every(isContentPart);
+  }
+  return false;
+}
+
+// src/tools/define.ts
+var mapSchema = (schema, transform) => {
+  if (!schema || typeof schema !== "object") return schema;
+  const next = transform({ ...schema });
+  if (next.properties) {
+    const updated = {};
+    for (const [key, value] of Object.entries(next.properties)) {
+      updated[key] = mapSchema(value, transform);
+    }
+    next.properties = updated;
+  }
+  if (next.items) {
+    if (Array.isArray(next.items)) {
+      next.items = next.items.map(
+        (item) => mapSchema(item, transform)
+      );
+    } else {
+      next.items = mapSchema(next.items, transform);
+    }
+  }
+  if (next.anyOf) {
+    next.anyOf = next.anyOf.map(
+      (item) => mapSchema(item, transform)
+    );
+  }
+  if (next.oneOf) {
+    next.oneOf = next.oneOf.map(
+      (item) => mapSchema(item, transform)
+    );
+  }
+  if (next.allOf) {
+    next.allOf = next.allOf.map(
+      (item) => mapSchema(item, transform)
+    );
+  }
+  if (next.not) {
+    next.not = mapSchema(next.not, transform);
+  }
+  return next;
+};
+var withNoAdditionalProperties = (schema) => mapSchema(schema, (next) => {
+  if (next.type === "object" && next.additionalProperties === void 0) {
+    next.additionalProperties = false;
+  }
+  return next;
+});
+var withRequiredProperties = (schema) => mapSchema(schema, (next) => {
+  if (next.type === "object" && next.properties) {
+    const propertyKeys = Object.keys(next.properties);
+    if (propertyKeys.length > 0) {
+      next.required = Array.from(
+        /* @__PURE__ */ new Set([...next.required ?? [], ...propertyKeys])
+      );
+    }
+  }
+  return next;
+});
+function toToolResult(value) {
+  if (isToolResult(value)) return value;
+  if (typeof value === "string") return { type: "text", text: value };
+  if (Array.isArray(value) && value.every(isContentPart))
+    return { type: "parts", parts: value };
+  return { type: "json", value };
+}
+function defineTool(toolOptions) {
+  const parameters = toJSONSchema(toolOptions.input, {
+    target: "draft-07",
+    io: "input"
+  });
+  const strictParameters = withRequiredProperties(
+    withNoAdditionalProperties(parameters)
+  );
+  return {
+    name: toolOptions.name,
+    description: toolOptions.description,
+    definition: {
+      name: toolOptions.name,
+      description: toolOptions.description,
+      parameters: strictParameters,
+      strict: true
+    },
+    executeRaw: (rawArgsJson, ctx) => {
+      let rawArgs;
+      try {
+        rawArgs = JSON.parse(rawArgsJson);
+      } catch (error) {
+        throw new Error(
+          `Invalid tool arguments JSON for ${toolOptions.name}: ${String(error)}`
+        );
+      }
+      const parsed = toolOptions.input.safeParse(rawArgs);
+      if (!parsed.success) {
+        throw new Error(
+          `Tool input validation failed for ${toolOptions.name}: ${parsed.error.message}`
+        );
+      }
+      const result = toolOptions.execute(parsed.data, ctx);
+      if (result instanceof Promise) {
+        return result.then((result2) => toToolResult(result2));
+      }
+      return Promise.resolve(toToolResult(result));
+    }
+  };
+}
+export {
+  ANTHROPIC_DEFAULT_MODEL,
+  ANTHROPIC_MODELS,
+  Agent,
+  ChatAnthropic,
+  ChatOpenAI,
+  DEFAULT_MODEL_REGISTRY,
+  GOOGLE_MODELS,
+  OPENAI_DEFAULT_MODEL,
+  OPENAI_DEFAULT_REASONING_EFFORT,
+  OPENAI_MODELS,
+  TaskComplete,
+  ToolOutputCacheService,
+  applyModelMetadata,
+  createModelRegistry,
+  defineTool,
+  getDefaultSystemPromptPath,
+  listModels,
+  registerModels,
+  resolveModel,
+  stringifyContent,
+  stringifyContentParts
+};