@archships/dim-agent-sdk 0.0.5 → 0.0.7

package/dist/index.js

@@ -0,0 +1,4820 @@
+// src/providers/core/create-provider-factory.ts
+function createProviderFactory(definition) {
+  return function createConfiguredAdapter(options) {
+    const provider = options.provider ?? definition.defaultProvider;
+    const defaultModel = {
+      provider,
+      modelId: options.defaultModel
+    };
+    return {
+      provider,
+      defaultModel,
+      async* stream(request) {
+        const requestId = request.requestId ?? crypto.randomUUID();
+        const model = request.model ?? defaultModel;
+        yield { type: "response_start", requestId, model };
+        const context = {
+          options,
+          provider,
+          defaultModel,
+          request: {
+            ...request,
+            model
+          }
+        };
+        let result;
+        try {
+          result = await definition.driver.generate(context);
+        } catch (error) {
+          const payload = definition.driver.normalizeError ? await definition.driver.normalizeError(error, context) : createFallbackErrorPayload(provider, error);
+          yield {
+            type: "error",
+            requestId,
+            error: payload,
+            terminal: true
+          };
+          return;
+        }
+        for (const segment of result.content) {
+          if (segment.type === "text") {
+            if (segment.text.length > 0)
+              yield { type: "text_delta", requestId, delta: segment.text };
+            continue;
+          }
+          if (segment.type === "thinking") {
+            if (segment.text.length > 0)
+              yield { type: "thinking_delta", requestId, delta: segment.text };
+            continue;
+          }
+          yield {
+            type: "tool_call_start",
+            requestId,
+            callId: segment.callId,
+            toolName: segment.toolName
+          };
+          yield {
+            type: "tool_call_args_delta",
+            requestId,
+            callId: segment.callId,
+            delta: segment.argsText
+          };
+          yield {
+            type: "tool_call_end",
+            requestId,
+            callId: segment.callId
+          };
+        }
+        yield {
+          type: "response_end",
+          requestId,
+          stopReason: result.stopReason,
+          usage: result.usage,
+          assistantMetadata: result.assistantMetadata
+        };
+      }
+    };
+  };
+}
+function createFallbackErrorPayload(provider, error) {
+  if (error instanceof Error) {
+    return {
+      code: `${provider}_request_error`,
+      message: error.message
+    };
+  }
+  return {
+    code: `${provider}_request_error`,
+    message: String(error)
+  };
+}
+
+// src/providers/aihubmix/driver.ts
+import { APICallError } from "@ai-sdk/provider";
+import { createAihubmix } from "@aihubmix/ai-sdk-provider";
+
+// src/providers/shared/usage.ts
+function normalizeLanguageModelUsage(raw) {
+  if (!raw)
+    return;
+  const promptTokens = raw.inputTokens.total ?? 0;
+  const completionTokens = raw.outputTokens.total ?? 0;
+  const totalTokens = promptTokens + completionTokens;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0)
+    return;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens
+  };
+}
+function mapLanguageModelFinishReason(reason) {
+  const raw = reason.raw?.toLowerCase();
+  if (raw === "cancelled" || raw === "canceled")
+    return "cancelled";
+  switch (reason.unified) {
+    case "tool-calls":
+      return "tool_call";
+    case "length":
+      return "length";
+    case "content-filter":
+    case "error":
+      return "error";
+    case "other":
+      return raw === "cancelled" || raw === "canceled" ? "cancelled" : "final";
+    case "stop":
+    default:
+      return "final";
+  }
+}
+
+// src/providers/shared/ai-sdk-driver.ts
+async function generateWithAiSdk(input) {
+  const result = await input.model.doGenerate(input.callOptions);
+  const content = [];
+  for (const part of result.content) {
+    if (part.type === "text") {
+      if (part.text.length > 0)
+        content.push({ type: "text", text: part.text });
+      continue;
+    }
+    if (part.type === "reasoning") {
+      if (part.text.length > 0)
+        content.push({ type: "thinking", text: part.text });
+      continue;
+    }
+    if (part.type === "tool-call") {
+      content.push({
+        type: "tool_call",
+        callId: part.toolCallId,
+        toolName: part.toolName,
+        argsText: part.input
+      });
+    }
+  }
+  return {
+    content,
+    stopReason: mapLanguageModelFinishReason(result.finishReason),
+    usage: normalizeLanguageModelUsage(result.usage),
+    assistantMetadata: input.createAssistantMetadata?.(result)
+  };
+}
+
+// src/providers/shared/auth-warning.ts
+var warnedProviders = new Set;
+function warnIfPlaceholderApiKey(input) {
+  if (!input.shouldWarn)
+    return;
+  if (false)
+    ;
+  if (warnedProviders.has(input.provider))
+    return;
+  warnedProviders.add(input.provider);
+  const suffix = input.hint ? ` ${input.hint}` : "";
+  console.warn(`[dim-agent-sdk] ${input.provider} is using a placeholder API key because no apiKey or provider-native auth configuration was provided. ` + `If you rely on external authentication, ensure your custom fetch or provider-native headers add real credentials before the request is sent upstream.${suffix}`);
+}
+
+// src/providers/shared/fetch.ts
+function createProviderFetch(input) {
+  const fetchImpl = input.fetch ?? globalThis.fetch;
+  if (!input.stripWhen || !input.stripHeaders || input.stripHeaders.length === 0)
+    return fetchImpl;
+  const headersToStrip = new Set(input.stripHeaders.map((header) => header.toLowerCase()));
+  const wrappedFetch = Object.assign((resource, init) => {
+    if (typeof resource === "string" || resource instanceof URL) {
+      const headers = new Headers(init?.headers);
+      for (const header of headersToStrip)
+        headers.delete(header);
+      return fetchImpl(resource, { ...init, headers });
+    }
+    const request = new Request(resource, init);
+    for (const header of headersToStrip)
+      request.headers.delete(header);
+    return fetchImpl(request);
+  }, {
+    preconnect: typeof fetchImpl.preconnect === "function" ? fetchImpl.preconnect.bind(fetchImpl) : (_url, _options) => {}
+  });
+  return wrappedFetch;
+}
+function hasHeader(headers, target) {
+  if (!headers)
+    return false;
+  const normalized = target.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === normalized);
+}
+
+// src/providers/shared/http-error.ts
+import { STATUS_CODES } from "node:http";
+var MAX_TEXT_CHARS = 4000;
+var MAX_JSON_DEPTH = 4;
+var MAX_JSON_ARRAY_ITEMS = 20;
+var MAX_JSON_OBJECT_KEYS = 40;
+var TRUNCATED_SUFFIX = "...[truncated]";
+function createApiCallErrorPayload(input) {
+  const responseBody = input.error.responseBody ? parseErrorBody(input.error.responseBody) : limitJsonValue(input.error.data);
+  return {
+    code: input.code,
+    message: `${input.provider} request failed${input.error.statusCode ? ` with status ${input.error.statusCode}` : ""}`,
+    status: input.error.statusCode,
+    retryable: input.error.isRetryable,
+    details: {
+      provider: input.provider,
+      endpoint: input.error.url,
+      ...input.error.statusCode ? { statusText: STATUS_CODES[input.error.statusCode] ?? undefined } : {},
+      ...responseBody === undefined ? {} : { responseBody }
+    }
+  };
+}
+function createRequestErrorPayload(input) {
+  if (input.error instanceof Error) {
+    return {
+      code: input.code,
+      message: input.error.message
+    };
+  }
+  return {
+    code: input.code,
+    message: String(input.error)
+  };
+}
+function parseErrorBody(value) {
+  const normalized = value.trim();
+  if (!normalized)
+    return;
+  try {
+    return limitJsonValue(JSON.parse(normalized));
+  } catch {
+    return truncateText(normalized);
+  }
+}
+function limitJsonValue(value, depth = 0) {
+  if (value === undefined)
+    return;
+  if (value === null || typeof value === "boolean" || typeof value === "number")
+    return value;
+  if (typeof value === "string")
+    return truncateText(value);
+  if (Array.isArray(value))
+    return value.slice(0, MAX_JSON_ARRAY_ITEMS).map((item) => limitJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (depth >= MAX_JSON_DEPTH)
+      return truncateText(JSON.stringify(value));
+    const limited = {};
+    for (const [key, child] of Object.entries(value).slice(0, MAX_JSON_OBJECT_KEYS))
+      limited[key] = limitJsonValue(child, depth + 1);
+    return limited;
+  }
+  return truncateText(String(value));
+}
+function truncateText(value) {
+  if (value.length <= MAX_TEXT_CHARS)
+    return value;
+  return `${value.slice(0, MAX_TEXT_CHARS)}${TRUNCATED_SUFFIX}`;
+}
+
+// src/utils/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+// src/contracts/content-normalize.ts
+function isTextContent(value) {
+  return isRecord(value) && value.type === "text" && typeof value.text === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isImageContent(value) {
+  return isRecord(value) && value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string" && (value.annotations === undefined || isRecord(value.annotations)) && (value._meta === undefined || isRecord(value._meta));
+}
+function isContentBlock(value) {
+  return isTextContent(value) || isImageContent(value);
+}
+function normalizeContent(input) {
+  if (typeof input === "string") {
+    return [{ type: "text", text: input }];
+  }
+  if (Array.isArray(input)) {
+    const blocks = input.filter((item) => item != null);
+    if (!blocks.every(isContentBlock))
+      throw new TypeError("Content array must contain only text or image blocks");
+    return blocks.map((block) => ({ ...block }));
+  }
+  if (!isContentBlock(input))
+    throw new TypeError("Content must be a string, content block, or content block array");
+  return [{ ...input }];
+}
+function contentToText(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+
+// src/utils/json.ts
+function isJsonSafeValue(value) {
+  if (value === null)
+    return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value))
+    return value.every(isJsonSafeValue);
+  if (isRecord(value))
+    return Object.values(value).every(isJsonSafeValue);
+  return false;
+}
+function assertJsonSafeObject(value, label) {
+  if (!isRecord(value) || !isJsonSafeValue(value))
+    throw new TypeError(`${label} must be a JSON-safe object`);
+}
+function parseJsonObject(value, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${label} must be valid JSON: ${message}`);
+  }
+  if (!isRecord(parsed))
+    throw new Error(`${label} must decode to a JSON object`);
+  return parsed;
+}
+
+// src/providers/shared/prompt.ts
+function mapToolDefinitionsToLanguageModelTools(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+}
+function messagesToLanguageModelPrompt(messages, options = {}) {
+  const prompt = [];
+  const systemContent = messages.filter((message) => message.role === "system").map((message) => contentToText(message.content)).filter(Boolean).join(`
+
+`);
+  if (systemContent)
+    prompt.push({ role: "system", content: systemContent });
+  for (const message of messages) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "tool") {
+      prompt.push(toolMessageToPrompt(message));
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = [
+        ...options.assistantPrefixParts?.(message) ?? [],
+        ...contentBlocksToPromptParts(message.content),
+        ...toolCallsToPromptParts(message.toolCalls)
+      ];
+      if (content.length > 0)
+        prompt.push({ role: "assistant", content });
+      continue;
+    }
+    prompt.push({
+      role: "user",
+      content: contentBlocksToPromptParts(message.content)
+    });
+  }
+  return prompt;
+}
+function contentBlocksToPromptParts(content) {
+  return content.map((block) => {
+    if (block.type === "text")
+      return { type: "text", text: block.text };
+    return {
+      type: "file",
+      data: block.data,
+      mediaType: block.mimeType
+    };
+  });
+}
+function toolCallsToPromptParts(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0)
+    return [];
+  return toolCalls.map((toolCall) => ({
+    type: "tool-call",
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name,
+    input: toolCall.function.arguments
+  }));
+}
+function toolMessageToPrompt(message) {
+  return {
+    role: "tool",
+    content: [{
+      type: "tool-result",
+      toolCallId: message.toolCallId,
+      toolName: message.toolName,
+      output: toolMessageToOutput(message)
+    }]
+  };
+}
+function toolMessageToOutput(message) {
+  if (message.structuredContent) {
+    assertJsonSafeObject(message.structuredContent, "Tool structuredContent");
+    return {
+      type: "json",
+      value: message.structuredContent
+    };
+  }
+  const text = contentToText(message.content);
+  if (message.isError === true) {
+    return {
+      type: "json",
+      value: {
+        content: text,
+        isError: true
+      }
+    };
+  }
+  return {
+    type: "text",
+    value: text
+  };
+}
+
+// src/providers/shared/reasoning.ts
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+var LOW_HIGH_REASONING_EFFORT_MAP = {
+  none: "low",
+  minimal: "low",
+  low: "low",
+  medium: "high",
+  high: "high",
+  xhigh: "high"
+};
+var LOW_MEDIUM_HIGH_REASONING_EFFORT_MAP = {
+  none: "low",
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "high"
+};
+function normalizeReasoningConfig(reasoning) {
+  if (!isRecord2(reasoning))
+    return;
+  if (reasoning.enabled === false)
+    return;
+  return reasoning;
+}
+function resolveReasoningBudget(reasoning, fallback = 1024) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  for (const key of ["budgetTokens", "budget_tokens", "thinkingBudget"]) {
+    const value = normalized[key];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0)
+      return Math.floor(value);
+  }
+  return fallback;
+}
+function resolveReasoningEffort(reasoning, allowedValues) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const rawEffort = normalized.reasoningEffort ?? normalized.effort;
+  if (typeof rawEffort !== "string" || rawEffort.length === 0)
+    return;
+  if (!allowedValues || allowedValues.includes(rawEffort))
+    return rawEffort;
+  return;
+}
+function resolveLowHighReasoningEffort(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const rawEffort = normalized.reasoningEffort ?? normalized.effort;
+  return typeof rawEffort === "string" ? LOW_HIGH_REASONING_EFFORT_MAP[rawEffort] : undefined;
+}
+function resolveLowMediumHighReasoningEffort(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const rawEffort = normalized.reasoningEffort ?? normalized.effort;
+  return typeof rawEffort === "string" ? LOW_MEDIUM_HIGH_REASONING_EFFORT_MAP[rawEffort] : undefined;
+}
+function buildOpenAIResponsesProviderOptions(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  const next = {};
+  for (const [key, value] of Object.entries(normalized)) {
+    if (key === "enabled" || key === "budgetTokens" || key === "budget_tokens" || key === "thinkingBudget" || key === "includeThoughts")
+      continue;
+    if (key === "effort") {
+      next.reasoningEffort = value;
+      continue;
+    }
+    if (key === "summary") {
+      next.reasoningSummary = value;
+      continue;
+    }
+    next[key] = value;
+  }
+  if (next.reasoningSummary === undefined)
+    next.reasoningSummary = "auto";
+  return next;
+}
+function buildOpenAIResponsesRequestReasoning(reasoning) {
+  const options = buildOpenAIResponsesProviderOptions(reasoning);
+  if (!options)
+    return;
+  const next = {};
+  if (typeof options.reasoningEffort === "string")
+    next.effort = options.reasoningEffort;
+  if (typeof options.reasoningSummary === "string")
+    next.summary = options.reasoningSummary;
+  return next.effort || next.summary ? next : undefined;
+}
+function buildReasoningEffortProviderOptions(reasoning, allowedValues) {
+  const reasoningEffort = resolveReasoningEffort(reasoning, allowedValues);
+  return reasoningEffort ? { reasoningEffort } : undefined;
+}
+function buildAnthropicThinkingProviderOptions(reasoning) {
+  const budget = resolveReasoningBudget(reasoning);
+  if (!budget)
+    return { thinking: undefined, sendReasoning: undefined };
+  return {
+    thinking: {
+      type: "enabled",
+      budgetTokens: budget
+    },
+    sendReasoning: true
+  };
+}
+function buildGeminiThinkingProviderOptions(reasoning) {
+  const normalized = normalizeReasoningConfig(reasoning);
+  if (!normalized)
+    return;
+  return {
+    thinkingConfig: {
+      thinkingBudget: resolveReasoningBudget(normalized) ?? 1024,
+      includeThoughts: normalized.includeThoughts !== false
+    }
+  };
+}
+function buildMoonshotThinkingProviderOptions(reasoning) {
+  const budget = resolveReasoningBudget(reasoning);
+  if (!budget)
+    return;
+  return {
+    thinking: {
+      type: "enabled",
+      budgetTokens: budget
+    }
+  };
+}
+function buildDeepSeekThinkingProviderOptions(reasoning) {
+  return normalizeReasoningConfig(reasoning) ? { thinking: { type: "enabled" } } : undefined;
+}
+
+// src/providers/aihubmix/driver.ts
+var PLACEHOLDER_API_KEY = "dim-placeholder-key";
+var AIHUBMIX_REASONING_EFFORTS = ["minimal", "low", "medium", "high", "none", "xhigh"];
+var aihubmixDriver = {
+  async generate(context) {
+    const model = createProvider(context.options).chat(context.request.model.modelId);
+    const aihubmixProviderOptions = buildReasoningEffortProviderOptions(context.request.reasoning, AIHUBMIX_REASONING_EFFORTS);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...aihubmixProviderOptions ? { providerOptions: { openai: aihubmixProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "aihubmix_http_error",
+        provider: "AIHubMix",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "aihubmix_request_error",
+      error
+    });
+  }
+};
+function createProvider(options) {
+  const stripAuthorization = !options.apiKey;
+  warnIfPlaceholderApiKey({
+    provider: "AIHubMix",
+    shouldWarn: stripAuthorization,
+    hint: "This adapter does not expose provider-native auth headers in its options, so external auth must be added inside custom fetch when apiKey is omitted."
+  });
+  return createAihubmix({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY,
+    compatibility: options.compatibility,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+
+// src/providers/aihubmix/adapter.ts
+var createAihubmixAdapter = createProviderFactory({
+  defaultProvider: "aihubmix",
+  driver: aihubmixDriver
+});
+// src/providers/aihubmix-responses/driver.ts
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
+import { createAihubmix as createAihubmix2 } from "@aihubmix/ai-sdk-provider";
+
+// src/providers/shared/provider-state.ts
+var PROVIDER_STATE_METADATA_KEY = "_dimProviderState";
+function attachProviderState(metadata, provider, state) {
+  if (!state || Object.keys(state).length === 0)
+    return metadata;
+  const nextMetadata = metadata ? structuredClone(metadata) : {};
+  const currentBag = isRecord3(nextMetadata[PROVIDER_STATE_METADATA_KEY]) ? nextMetadata[PROVIDER_STATE_METADATA_KEY] : {};
+  nextMetadata[PROVIDER_STATE_METADATA_KEY] = {
+    ...currentBag,
+    [provider]: structuredClone(state)
+  };
+  return nextMetadata;
+}
+function readProviderState(message, provider) {
+  if (message.role !== "assistant" || !isRecord3(message.metadata))
+    return;
+  const bag = message.metadata[PROVIDER_STATE_METADATA_KEY];
+  if (!isRecord3(bag))
+    return;
+  const state = bag[provider];
+  return isRecord3(state) ? structuredClone(state) : undefined;
+}
+function isRecord3(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providers/shared/responses-state.ts
+function sliceMessagesForResponses(messages, stateKey) {
+  let previousResponseId;
+  let startIndex = 0;
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const state = readProviderState(messages[index], stateKey);
+    if (typeof state?.responseId === "string") {
+      previousResponseId = state.responseId;
+      startIndex = index + 1;
+      break;
+    }
+  }
+  return {
+    messages: messages.slice(startIndex),
+    previousResponseId
+  };
+}
+function createResponsesAssistantMetadata(input) {
+  const responseId = resolveResponseId(input.result, input.providerMetadataKey);
+  if (!responseId)
+    return;
+  return attachProviderState(undefined, input.stateKey, { responseId });
+}
+function resolveResponseId(result, providerMetadataKey) {
+  const providerMetadata = providerMetadataKey ? result.providerMetadata?.[providerMetadataKey] : undefined;
+  if (isRecord(providerMetadata) && typeof providerMetadata.responseId === "string")
+    return providerMetadata.responseId;
+  if (typeof result.response?.id === "string")
+    return result.response.id;
+  return extractResponseIdFromBody(result.response?.body);
+}
+function extractResponseIdFromBody(body) {
+  if (isRecord(body) && typeof body.id === "string")
+    return body.id;
+  if (typeof body !== "string")
+    return;
+  try {
+    const parsed = JSON.parse(body);
+    return isRecord(parsed) && typeof parsed.id === "string" ? parsed.id : undefined;
+  } catch {
+    return;
+  }
+}
+
+// src/providers/aihubmix-responses/state.ts
+var AIHUBMIX_RESPONSES_STATE_KEY = "aihubmixResponses";
+function sliceMessagesForAihubmixResponses(messages) {
+  return sliceMessagesForResponses(messages, AIHUBMIX_RESPONSES_STATE_KEY);
+}
+function createAihubmixResponsesAssistantMetadata(result) {
+  return createResponsesAssistantMetadata({
+    result,
+    stateKey: AIHUBMIX_RESPONSES_STATE_KEY,
+    providerMetadataKey: "aihubmix"
+  });
+}
+
+// src/providers/aihubmix-responses/driver.ts
+var PLACEHOLDER_API_KEY2 = "dim-placeholder-key";
+var aihubmixResponsesDriver = {
+  async generate(context) {
+    const requestReasoning = buildOpenAIResponsesRequestReasoning(context.request.reasoning);
+    const model = createProvider2(context.options, requestReasoning).responses(context.request.model.modelId);
+    const { messages, previousResponseId } = sliceMessagesForAihubmixResponses(context.request.messages);
+    const aihubmixProviderOptions = {
+      ...buildOpenAIResponsesProviderOptions(context.request.reasoning) ?? {},
+      ...previousResponseId ? { previousResponseId } : {}
+    };
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...Object.keys(aihubmixProviderOptions).length > 0 ? { providerOptions: { openai: aihubmixProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions,
+      createAssistantMetadata: createAihubmixResponsesAssistantMetadata
+    });
+  },
+  normalizeError(error) {
+    if (APICallError2.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "aihubmix_responses_http_error",
+        provider: "AIHubMix Responses",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "aihubmix_responses_request_error",
+      error
+    });
+  }
+};
+function createProvider2(options, requestReasoning) {
+  const stripAuthorization = !options.apiKey;
+  warnIfPlaceholderApiKey({
+    provider: "AIHubMix Responses",
+    shouldWarn: stripAuthorization,
+    hint: "This adapter does not expose provider-native auth headers in its options, so external auth must be added inside custom fetch when apiKey is omitted."
+  });
+  return createAihubmix2({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY2,
+    compatibility: options.compatibility,
+    fetch: createReasoningAwareResponsesFetch({
+      fetch: options.fetch,
+      stripAuthorization,
+      requestReasoning
+    })
+  });
+}
+function createReasoningAwareResponsesFetch(input) {
+  const baseFetch = createProviderFetch({
+    fetch: input.fetch,
+    stripHeaders: ["authorization"],
+    stripWhen: input.stripAuthorization
+  });
+  if (!input.requestReasoning)
+    return baseFetch;
+  const wrappedFetch = Object.assign(async (resource, init) => {
+    if (!init?.body)
+      return baseFetch(resource, init);
+    const body = parseJsonBody(init.body);
+    if (!isRecord(body) || body.reasoning !== undefined)
+      return baseFetch(resource, init);
+    return baseFetch(resource, {
+      ...init,
+      body: JSON.stringify({
+        ...body,
+        reasoning: input.requestReasoning
+      })
+    });
+  }, {
+    preconnect: typeof baseFetch.preconnect === "function" ? baseFetch.preconnect.bind(baseFetch) : undefined
+  });
+  return wrappedFetch;
+}
+function parseJsonBody(body) {
+  if (typeof body !== "string")
+    return;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return;
+  }
+}
+
+// src/providers/aihubmix-responses/adapter.ts
+var createAihubmixResponsesAdapter = createProviderFactory({
+  defaultProvider: "aihubmix-responses",
+  driver: aihubmixResponsesDriver
+});
+// src/providers/anthropic/driver.ts
+import { APICallError as APICallError3 } from "@ai-sdk/provider";
+import { createAnthropic } from "@ai-sdk/anthropic";
+
+// src/providers/anthropic/state.ts
+var ANTHROPIC_STATE_KEY = "anthropic";
+function anthropicAssistantPrefixParts(message) {
+  const state = readProviderState(message, ANTHROPIC_STATE_KEY);
+  const rawBlocks = state?.blocks;
+  if (!Array.isArray(rawBlocks))
+    return [];
+  const parts = [];
+  for (const rawBlock of rawBlocks) {
+    if (!isRecord(rawBlock) || typeof rawBlock.type !== "string")
+      continue;
+    if (rawBlock.type === "thinking" && typeof rawBlock.signature === "string") {
+      parts.push({
+        type: "reasoning",
+        text: typeof rawBlock.thinking === "string" ? rawBlock.thinking : "",
+        providerOptions: {
+          anthropic: {
+            signature: rawBlock.signature
+          }
+        }
+      });
+      continue;
+    }
+    if (rawBlock.type === "redacted_thinking" && typeof rawBlock.data === "string") {
+      parts.push({
+        type: "reasoning",
+        text: "",
+        providerOptions: {
+          anthropic: {
+            redactedData: rawBlock.data
+          }
+        }
+      });
+    }
+  }
+  return parts;
+}
+function createAnthropicAssistantMetadata(result) {
+  const blocks = result.content.flatMap((part) => {
+    if (part.type !== "reasoning")
+      return [];
+    const metadata = part.providerMetadata?.anthropic;
+    if (!isRecord(metadata))
+      return [];
+    if (typeof metadata.signature === "string") {
+      return [{
+        type: "thinking",
+        thinking: part.text,
+        signature: metadata.signature
+      }];
+    }
+    if (typeof metadata.redactedData === "string") {
+      return [{
+        type: "redacted_thinking",
+        data: metadata.redactedData
+      }];
+    }
+    return [];
+  });
+  if (blocks.length === 0)
+    return;
+  return attachProviderState(undefined, ANTHROPIC_STATE_KEY, { blocks });
+}
+
+// src/providers/anthropic/driver.ts
+var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+var PLACEHOLDER_API_KEY3 = "dim-placeholder-key";
+var anthropicDriver = {
+  async generate(context) {
+    const model = createProvider3(context.options)(context.request.model.modelId);
+    const prompt = messagesToLanguageModelPrompt(context.request.messages, {
+      assistantPrefixParts: anthropicAssistantPrefixParts
+    });
+    const anthropicProviderOptions = {
+      ...buildAnthropicThinkingProviderOptions(context.request.reasoning) ?? {},
+      ...hasReasoningState(context.request.messages) ? { sendReasoning: true } : {}
+    };
+    const callOptions = {
+      prompt,
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...Object.keys(anthropicProviderOptions).length > 0 ? { providerOptions: { anthropic: anthropicProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions,
+      createAssistantMetadata: createAnthropicAssistantMetadata
+    });
+  },
+  normalizeError(error) {
+    if (APICallError3.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "anthropic_http_error",
+        provider: "Anthropic",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "anthropic_request_error",
+      error
+    });
+  }
+};
+function createProvider3(options) {
+  const stripAuthentication = !options.apiKey && !hasHeader(options.headers, "x-api-key") && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "Anthropic",
+    shouldWarn: stripAuthentication
+  });
+  return createAnthropic({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY3,
+    ...options.baseUrl ? { baseURL: normalizeBaseUrl(options.baseUrl) } : {},
+    headers: {
+      "anthropic-version": options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION,
+      ...options.headers
+    },
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["x-api-key", "authorization"],
+      stripWhen: stripAuthentication
+    })
+  });
+}
+function hasReasoningState(messages) {
+  return messages.some((message) => message.role === "assistant" && anthropicAssistantPrefixParts(message).length > 0);
+}
+function normalizeBaseUrl(baseUrl) {
+  const normalized = (baseUrl ?? "").replace(/\/$/, "");
+  return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+
+// src/providers/anthropic/adapter.ts
+var createAnthropicAdapter = createProviderFactory({
+  defaultProvider: "anthropic",
+  driver: anthropicDriver
+});
+// src/providers/deepseek/driver.ts
+import { APICallError as APICallError4 } from "@ai-sdk/provider";
+import { createDeepSeek } from "@ai-sdk/deepseek";
+var DEFAULT_BASE_URL = "https://api.deepseek.com";
+var PLACEHOLDER_API_KEY4 = "dim-placeholder-key";
+var deepSeekDriver = {
+  async generate(context) {
+    const model = createProvider4(context.options).chat(context.request.model.modelId);
+    const deepseekProviderOptions = buildDeepSeekThinkingProviderOptions(context.request.reasoning);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...deepseekProviderOptions ? { providerOptions: { deepseek: deepseekProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError4.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "deepseek_http_error",
+        provider: "DeepSeek",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "deepseek_request_error",
+      error
+    });
+  }
+};
+function createProvider4(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "DeepSeek",
+    shouldWarn: stripAuthorization
+  });
+  return createDeepSeek({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY4,
+    baseURL: normalizeBaseUrl2(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl2(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+
+// src/providers/deepseek/adapter.ts
+var createDeepSeekAdapter = createProviderFactory({
+  defaultProvider: "deepseek",
+  driver: deepSeekDriver
+});
+// src/providers/gemini/driver.ts
+import { APICallError as APICallError5 } from "@ai-sdk/provider";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+
+// src/providers/gemini/state.ts
+var GEMINI_STATE_KEY = "gemini";
+function geminiAssistantPrefixParts(message) {
+  const state = readProviderState(message, GEMINI_STATE_KEY);
+  const rawParts = state?.parts;
+  if (!Array.isArray(rawParts))
+    return [];
+  const parts = [];
+  for (const rawPart of rawParts) {
+    if (!isRecord(rawPart))
+      continue;
+    const thoughtSignature = typeof rawPart.thoughtSignature === "string" ? rawPart.thoughtSignature : undefined;
+    if (isRecord(rawPart.functionCall) && typeof rawPart.functionCall.name === "string") {
+      parts.push({
+        type: "tool-call",
+        toolCallId: crypto.randomUUID(),
+        toolName: rawPart.functionCall.name,
+        input: isRecord(rawPart.functionCall.args) ? rawPart.functionCall.args : {},
+        ...thoughtSignature ? {
+          providerOptions: {
+            google: {
+              thoughtSignature
+            }
+          }
+        } : {}
+      });
+      continue;
+    }
+    if (typeof rawPart.text === "string") {
+      parts.push({
+        type: rawPart.thought === true ? "reasoning" : "text",
+        text: rawPart.text,
+        ...thoughtSignature ? {
+          providerOptions: {
+            google: {
+              thoughtSignature
+            }
+          }
+        } : {}
+      });
+    }
+  }
+  return parts;
+}
+function createGeminiAssistantMetadata(result) {
+  const parts = result.content.flatMap((part) => {
+    const metadata = part.providerMetadata?.google;
+    const thoughtSignature = isRecord(metadata) && typeof metadata.thoughtSignature === "string" ? metadata.thoughtSignature : undefined;
+    if (!thoughtSignature && part.type !== "reasoning")
+      return [];
+    if (part.type === "reasoning") {
+      return [{
+        text: part.text,
+        thought: true,
+        thoughtSignature
+      }];
+    }
+    if (part.type === "tool-call") {
+      return [{
+        functionCall: {
+          name: part.toolName,
+          args: parseToolArguments(part.input)
+        },
+        thoughtSignature
+      }];
+    }
+    if (part.type === "text") {
+      return [{
+        text: part.text,
+        thoughtSignature
+      }];
+    }
+    return [];
+  });
+  if (parts.length === 0)
+    return;
+  return attachProviderState(undefined, GEMINI_STATE_KEY, { parts });
+}
+function parseToolArguments(input) {
+  try {
+    const parsed = JSON.parse(input);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+// src/providers/gemini/driver.ts
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com";
+var PLACEHOLDER_API_KEY5 = "dim-placeholder-key";
+var geminiDriver = {
+  async generate(context) {
+    const model = createProvider5(context.options)(context.request.model.modelId);
+    const googleProviderOptions = buildGeminiThinkingProviderOptions(context.request.reasoning);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages, {
+        assistantPrefixParts: geminiAssistantPrefixParts
+      }),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...googleProviderOptions ? { providerOptions: { google: googleProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions,
+      createAssistantMetadata: createGeminiAssistantMetadata
+    });
+  },
+  normalizeError(error) {
+    if (APICallError5.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "gemini_http_error",
+        provider: "Gemini",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "gemini_request_error",
+      error
+    });
+  }
+};
+function createProvider5(options) {
+  const stripApiKey = !options.apiKey && !hasHeader(options.headers, "x-goog-api-key");
+  warnIfPlaceholderApiKey({
+    provider: "Gemini",
+    shouldWarn: stripApiKey
+  });
+  return createGoogleGenerativeAI({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY5,
+    baseURL: normalizeBaseUrl3(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["x-goog-api-key"],
+      stripWhen: stripApiKey
+    })
+  });
+}
+function normalizeBaseUrl3(baseUrl) {
+  const normalized = (baseUrl ?? DEFAULT_BASE_URL2).replace(/\/$/, "");
+  return normalized.endsWith("/v1beta") ? normalized : `${normalized}/v1beta`;
+}
+
+// src/providers/gemini/adapter.ts
+var createGeminiAdapter = createProviderFactory({
+  defaultProvider: "gemini",
+  driver: geminiDriver
+});
+// src/providers/moonshotai/driver.ts
+import { APICallError as APICallError6 } from "@ai-sdk/provider";
+import { createMoonshotAI } from "@ai-sdk/moonshotai";
+var DEFAULT_BASE_URL3 = "https://api.moonshot.ai/v1";
+var PLACEHOLDER_API_KEY6 = "dim-placeholder-key";
+var moonshotAIDriver = {
+  async generate(context) {
+    const model = createProvider6(context.options).languageModel(context.request.model.modelId);
+    const moonshotaiProviderOptions = buildMoonshotThinkingProviderOptions(context.request.reasoning);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...moonshotaiProviderOptions ? { providerOptions: { moonshotai: moonshotaiProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError6.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "moonshotai_http_error",
+        provider: "MoonshotAI",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "moonshotai_request_error",
+      error
+    });
+  }
+};
+function createProvider6(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "MoonshotAI",
+    shouldWarn: stripAuthorization
+  });
+  return createMoonshotAI({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY6,
+    baseURL: normalizeBaseUrl4(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl4(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL3).replace(/\/$/, "");
+}
+
+// src/providers/moonshotai/adapter.ts
+var createMoonshotAIAdapter = createProviderFactory({
+  defaultProvider: "moonshotai",
+  driver: moonshotAIDriver
+});
+// src/providers/openai/driver.ts
+import { APICallError as APICallError7 } from "@ai-sdk/provider";
+import { createOpenAI } from "@ai-sdk/openai";
+var DEFAULT_BASE_URL4 = "https://api.openai.com/v1";
+var PLACEHOLDER_API_KEY7 = "dim-placeholder-key";
+var openAIDriver = {
+  async generate(context) {
+    const model = createProvider7(context.options).chat(context.request.model.modelId);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError7.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "openai_http_error",
+        provider: "OpenAI-compatible",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "openai_request_error",
+      error
+    });
+  }
+};
+function createProvider7(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "OpenAI-compatible",
+    shouldWarn: stripAuthorization
+  });
+  return createOpenAI({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY7,
+    baseURL: normalizeBaseUrl5(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl5(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL4).replace(/\/$/, "");
+}
+
+// src/providers/openai/adapter.ts
+var createOpenAIAdapter = createProviderFactory({
+  defaultProvider: "openai-compatible",
+  driver: openAIDriver
+});
+// src/providers/openai-responses/driver.ts
+import { APICallError as APICallError8 } from "@ai-sdk/provider";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+
+// src/providers/openai-responses/state.ts
+var OPENAI_RESPONSES_STATE_KEY = "openaiResponses";
+function sliceMessagesForOpenAIResponses(messages) {
+  return sliceMessagesForResponses(messages, OPENAI_RESPONSES_STATE_KEY);
+}
+function createOpenAIResponsesAssistantMetadata(result) {
+  return createResponsesAssistantMetadata({
+    result,
+    stateKey: OPENAI_RESPONSES_STATE_KEY,
+    providerMetadataKey: "openai"
+  });
+}
+
+// src/providers/openai-responses/driver.ts
+var DEFAULT_BASE_URL5 = "https://api.openai.com/v1";
+var PLACEHOLDER_API_KEY8 = "dim-placeholder-key";
+var openAIResponsesDriver = {
+  async generate(context) {
+    const model = createProvider8(context.options).responses(context.request.model.modelId);
+    const { messages, previousResponseId } = sliceMessagesForOpenAIResponses(context.request.messages);
+    const openaiProviderOptions = {
+      ...buildOpenAIResponsesProviderOptions(context.request.reasoning) ?? {},
+      ...previousResponseId ? { previousResponseId } : {}
+    };
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...Object.keys(openaiProviderOptions).length > 0 ? { providerOptions: { openai: openaiProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions,
+      createAssistantMetadata: createOpenAIResponsesAssistantMetadata
+    });
+  },
+  normalizeError(error) {
+    if (APICallError8.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "openai_responses_http_error",
+        provider: "OpenAI Responses",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "openai_responses_request_error",
+      error
+    });
+  }
+};
+function createProvider8(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "OpenAI Responses",
+    shouldWarn: stripAuthorization
+  });
+  return createOpenAI2({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY8,
+    baseURL: normalizeBaseUrl6(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl6(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL5).replace(/\/$/, "");
+}
+
+// src/providers/openai-responses/adapter.ts
+var createOpenAIResponsesAdapter = createProviderFactory({
+  defaultProvider: "openai-responses",
+  driver: openAIResponsesDriver
+});
+// src/providers/xai/driver.ts
+import { APICallError as APICallError9 } from "@ai-sdk/provider";
+import { createXai } from "@ai-sdk/xai";
+var DEFAULT_BASE_URL6 = "https://api.x.ai/v1";
+var PLACEHOLDER_API_KEY9 = "dim-placeholder-key";
+var xaiDriver = {
+  async generate(context) {
+    const model = createProvider9(context.options).chat(context.request.model.modelId);
+    const reasoningEffort = resolveLowHighReasoningEffort(context.request.reasoning);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...reasoningEffort ? { providerOptions: { xai: { reasoningEffort } } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError9.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "xai_http_error",
+        provider: "xAI",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "xai_request_error",
+      error
+    });
+  }
+};
+function createProvider9(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "xAI",
+    shouldWarn: stripAuthorization
+  });
+  return createXai({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY9,
+    baseURL: normalizeBaseUrl7(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl7(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL6).replace(/\/$/, "");
+}
+
+// src/providers/xai/adapter.ts
+var createXaiAdapter = createProviderFactory({
+  defaultProvider: "xai",
+  driver: xaiDriver
+});
+// src/providers/xai-responses/driver.ts
+import { APICallError as APICallError10 } from "@ai-sdk/provider";
+import { createXai as createXai2 } from "@ai-sdk/xai";
+
+// src/providers/xai-responses/state.ts
+var XAI_RESPONSES_STATE_KEY = "xaiResponses";
+function sliceMessagesForXaiResponses(messages) {
+  return sliceMessagesForResponses(messages, XAI_RESPONSES_STATE_KEY);
+}
+function createXaiResponsesAssistantMetadata(result) {
+  return createResponsesAssistantMetadata({
+    result,
+    stateKey: XAI_RESPONSES_STATE_KEY,
+    providerMetadataKey: "xai"
+  });
+}
+
+// src/providers/xai-responses/driver.ts
+var DEFAULT_BASE_URL7 = "https://api.x.ai/v1";
+var PLACEHOLDER_API_KEY10 = "dim-placeholder-key";
+var xaiResponsesDriver = {
+  async generate(context) {
+    const model = createProvider10(context.options).responses(context.request.model.modelId);
+    const { messages, previousResponseId } = sliceMessagesForXaiResponses(context.request.messages);
+    const reasoningEffort = resolveLowMediumHighReasoningEffort(context.request.reasoning);
+    const xaiProviderOptions = {
+      ...reasoningEffort ? { reasoningEffort } : {},
+      ...previousResponseId ? { previousResponseId } : {}
+    };
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...Object.keys(xaiProviderOptions).length > 0 ? { providerOptions: { xai: xaiProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions,
+      createAssistantMetadata: createXaiResponsesAssistantMetadata
+    });
+  },
+  normalizeError(error) {
+    if (APICallError10.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "xai_responses_http_error",
+        provider: "xAI Responses",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "xai_responses_request_error",
+      error
+    });
+  }
+};
+function createProvider10(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "xAI Responses",
+    shouldWarn: stripAuthorization
+  });
+  return createXai2({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY10,
+    baseURL: normalizeBaseUrl8(options.baseUrl),
+    headers: options.headers,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl8(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL7).replace(/\/$/, "");
+}
+
+// src/providers/xai-responses/adapter.ts
+var createXaiResponsesAdapter = createProviderFactory({
+  defaultProvider: "xai-responses",
+  driver: xaiResponsesDriver
+});
+// src/providers/zenmux/driver.ts
+import { APICallError as APICallError11 } from "@ai-sdk/provider";
+import { createZenMux } from "@zenmux/ai-sdk-provider";
+var DEFAULT_BASE_URL8 = "https://zenmux.ai/api/v1";
+var PLACEHOLDER_API_KEY11 = "dim-placeholder-key";
+var ZENMUX_REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
+var zenmuxDriver = {
+  async generate(context) {
+    const model = createProvider11(context.options).chat(context.request.model.modelId);
+    const zenmuxProviderOptions = buildReasoningEffortProviderOptions(context.request.reasoning, ZENMUX_REASONING_EFFORTS);
+    const callOptions = {
+      prompt: messagesToLanguageModelPrompt(context.request.messages),
+      tools: mapToolDefinitionsToLanguageModelTools(context.request.tools),
+      maxOutputTokens: context.request.maxOutputTokens,
+      temperature: context.request.temperature,
+      topP: context.request.topP,
+      stopSequences: context.request.stop,
+      abortSignal: context.request.signal,
+      ...zenmuxProviderOptions ? { providerOptions: { zenmux: zenmuxProviderOptions } } : {}
+    };
+    return generateWithAiSdk({
+      model,
+      callOptions
+    });
+  },
+  normalizeError(error) {
+    if (APICallError11.isInstance(error)) {
+      return createApiCallErrorPayload({
+        code: "zenmux_http_error",
+        provider: "ZenMux",
+        error
+      });
+    }
+    return createRequestErrorPayload({
+      code: "zenmux_request_error",
+      error
+    });
+  }
+};
+function createProvider11(options) {
+  const stripAuthorization = !options.apiKey && !hasHeader(options.headers, "authorization");
+  warnIfPlaceholderApiKey({
+    provider: "ZenMux",
+    shouldWarn: stripAuthorization
+  });
+  return createZenMux({
+    apiKey: options.apiKey ?? PLACEHOLDER_API_KEY11,
+    baseURL: normalizeBaseUrl9(options.baseUrl),
+    headers: options.headers,
+    organization: options.organization,
+    project: options.project,
+    fetch: createProviderFetch({
+      fetch: options.fetch,
+      stripHeaders: ["authorization"],
+      stripWhen: stripAuthorization
+    })
+  });
+}
+function normalizeBaseUrl9(baseUrl) {
+  return (baseUrl ?? DEFAULT_BASE_URL8).replace(/\/$/, "");
+}
+
+// src/providers/zenmux/adapter.ts
+var createZenMuxAdapter = createProviderFactory({
+  defaultProvider: "zenmux",
+  driver: zenmuxDriver
+});
+// src/context/auto-context-manager.ts
+import path from "node:path";
+
+// src/utils/id.ts
+function createId(prefix) {
+  return `${prefix}_${crypto.randomUUID()}`;
+}
+
+// src/context/auto-context-manager.ts
+class AutoContextManager {
+  services;
+  pluginHost;
+  maxItems;
+  maxChars;
+  constructor(options) {
+    this.services = options.services;
+    this.pluginHost = options.pluginHost;
+    this.maxItems = options.maxItems ?? 8;
+    this.maxChars = options.maxChars ?? 8000;
+  }
+  async resolve(options) {
+    const items = [];
+    if (options.cwd) {
+      items.push({
+        id: createId("ctx"),
+        type: "cwd",
+        title: "Working directory",
+        content: options.cwd,
+        priority: 10,
+        source: "agent"
+      });
+    }
+    items.push(...await this.resolveExplicitFiles(options.input, options.cwd));
+    items.push(...await this.resolveRecentFiles(options.cwd));
+    items.push(...await this.resolveGitState(options.cwd));
+    const contributed = await this.pluginHost?.collectContext({
+      sessionId: options.sessionId,
+      input: options.input,
+      messages: options.messages,
+      cwd: options.cwd
+    });
+    if (contributed)
+      items.push(...contributed);
+    return budgetContext(items, this.maxItems, this.maxChars);
+  }
+  format(items) {
+    if (items.length === 0)
+      return [];
+    const sections = items.map((item) => {
+      return [`[${item.title}]`, item.content].join(`
+`);
+    });
+    return [`Additional context for this turn:
+
+${sections.join(`
+
+`)}`];
+  }
+  async resolveExplicitFiles(input, cwd) {
+    const text = inputToText(input);
+    const candidates = extractFileCandidates(text);
+    const items = [];
+    for (const candidate of candidates) {
+      if (!cwd)
+        break;
+      if (!await this.services.fileSystem.exists(candidate, { cwd }))
+        continue;
+      const content = await safeReadText(this.services, candidate, cwd);
+      if (!content)
+        continue;
+      items.push({
+        id: createId("ctx"),
+        type: "file",
+        title: `File: ${candidate}`,
+        content,
+        priority: 100,
+        source: "explicit-file"
+      });
+    }
+    return items;
+  }
+  async resolveRecentFiles(cwd) {
+    if (!cwd || !this.pluginHost)
+      return [];
+    const items = [];
+    for (const filePath of this.pluginHost.recentFiles(3)) {
+      const relative = toRelative(cwd, filePath);
+      const content = await safeReadText(this.services, relative, cwd);
+      if (!content)
+        continue;
+      items.push({
+        id: createId("ctx"),
+        type: "file",
+        title: `Recent file: ${relative}`,
+        content,
+        priority: 70,
+        source: "recent-file"
+      });
+    }
+    return items;
+  }
+  async resolveGitState(cwd) {
+    if (!cwd)
+      return [];
+    const items = [];
+    const status = await this.services.git.status({ cwd });
+    if (status) {
+      items.push({
+        id: createId("ctx"),
+        type: "git_status",
+        title: "Git status",
+        content: status,
+        priority: 60,
+        source: "git"
+      });
+    }
+    const diff = await this.services.git.diff({ cwd });
+    if (diff) {
+      items.push({
+        id: createId("ctx"),
+        type: "git_diff",
+        title: "Git diff",
+        content: trimText(diff, 4000),
+        priority: 50,
+        source: "git"
+      });
+    }
+    return items;
+  }
+}
+function inputToText(input) {
+  return contentToText(normalizeContent(input));
+}
+function extractFileCandidates(text) {
+  const matches = text.match(/(?:[A-Za-z0-9._-]+\/)*[A-Za-z0-9._-]+\.[A-Za-z0-9_-]+/g) ?? [];
+  return [...new Set(matches)];
+}
+function trimText(text, maxChars) {
+  return text.length <= maxChars ? text : `${text.slice(0, maxChars)}
+...`;
+}
+async function safeReadText(services, filePath, cwd) {
+  try {
+    const text = await services.fileSystem.readText(filePath, { cwd });
+    return trimText(text, 2000);
+  } catch {
+    return null;
+  }
+}
+function budgetContext(items, maxItems, maxChars) {
+  const sorted = [...items].sort((left, right) => right.priority - left.priority);
+  const selected = [];
+  let totalChars = 0;
+  for (const item of sorted) {
+    if (selected.length >= maxItems)
+      break;
+    if (totalChars + item.content.length > maxChars && selected.length > 0)
+      continue;
+    selected.push(item);
+    totalChars += item.content.length;
+  }
+  return selected;
+}
+function toRelative(cwd, filePath) {
+  if (!path.isAbsolute(filePath))
+    return filePath;
+  return path.relative(cwd, filePath) || path.basename(filePath);
+}
+// src/plugin-host/helpers.ts
+function isHookControlResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return (candidate.type === "continue" || candidate.type === "replace" || candidate.type === "stop") && "payload" in candidate;
+}
+function isToolBeforeExecuteControlResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return candidate.type === "allow" || candidate.type === "deny" || candidate.type === "ask" || candidate.type === "replaceToolCall" || candidate.type === "provideResult";
+}
+function isNotificationControlResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return candidate.type === "continue" || candidate.type === "replace" || candidate.type === "suppress";
+}
+function isRunStopControlResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return candidate.type === "continue" || candidate.type === "finalize";
+}
+
+// src/plugin-host/hook-pipeline.ts
+class HookPipeline {
+  registrations = [];
+  nextOrder = 0;
+  register(pluginId, pluginPriority, hooks, services) {
+    if (!hooks)
+      return;
+    for (const entry of hooks) {
+      if (!entry.middleware?.length && !entry.observers?.length)
+        continue;
+      if (entry.descriptor.name === "model.event" && entry.middleware && entry.middleware.length > 0)
+        throw new Error(`Plugin ${pluginId} cannot register middleware for model.event`);
+      if (entry.descriptor.mode === "async" && entry.middleware && entry.middleware.length > 0)
+        throw new Error(`Plugin ${pluginId} cannot register async middleware for ${entry.descriptor.name}`);
+      this.registrations.push({
+        pluginId,
+        order: this.nextOrder++,
+        priority: entry.descriptor.priority ?? pluginPriority,
+        descriptor: entry.descriptor,
+        services,
+        middleware: [...entry.middleware ?? []],
+        observers: [...entry.observers ?? []]
+      });
+    }
+    this.registrations.sort((left, right) => {
+      if (left.priority !== right.priority)
+        return right.priority - left.priority;
+      return left.order - right.order;
+    });
+  }
+  async runMiddleware(name, payload, context) {
+    let current = payload;
+    for (const registration of this.matchingRegistrations(name, current)) {
+      for (const middleware of registration.middleware) {
+        const result = await this.runMiddlewareHandler(registration, middleware, current, context);
+        if (result === undefined)
+          continue;
+        if (isHookControlResult(result)) {
+          current = result.payload;
+          if (result.type === "stop")
+            return current;
+          continue;
+        }
+        if (isNotificationControlResult(result) || isRunStopControlResult(result) || isToolBeforeExecuteControlResult(result))
+          throw new Error(`Hook ${registration.descriptor.name} returned an unsupported control result`);
+        current = result;
+      }
+    }
+    return current;
+  }
+  async runToolBeforeExecute(payload, context) {
+    let current = payload;
+    for (const registration of this.matchingRegistrations("tool.beforeExecute", current)) {
+      for (const middleware of registration.middleware) {
+        const result = await this.runMiddlewareHandler(registration, middleware, current, context);
+        if (result === undefined)
+          continue;
+        if (isHookControlResult(result)) {
+          current = result.payload;
+          if (result.type === "stop")
+            return { payload: current };
+          continue;
+        }
+        if (isToolBeforeExecuteControlResult(result)) {
+          if (result.type === "replaceToolCall") {
+            current = { ...current, toolCall: result.toolCall };
+            continue;
+          }
+          if (result.type === "ask" && result.toolCall)
+            current = { ...current, toolCall: result.toolCall };
+          return { payload: current, control: result };
+        }
+        current = result;
+      }
+    }
+    return { payload: current };
+  }
+  async runNotifyMessage(payload, context) {
+    let current = payload;
+    for (const registration of this.matchingRegistrations("notify.message", current)) {
+      for (const middleware of registration.middleware) {
+        const result = await this.runMiddlewareHandler(registration, middleware, current, context);
+        if (result === undefined)
+          continue;
+        if (isHookControlResult(result)) {
+          current = result.payload;
+          if (result.type === "stop")
+            return { payload: current };
+          continue;
+        }
+        if (isNotificationControlResult(result)) {
+          if (result.type === "replace") {
+            current = { ...current, notification: result.notification };
+            continue;
+          }
+          if (result.type === "suppress")
+            return { payload: current, suppressed: true };
+          continue;
+        }
+        current = result;
+      }
+    }
+    return { payload: current };
+  }
+  async runRunStop(payload, context) {
+    let current = payload;
+    for (const registration of this.matchingRegistrations("run.stop", current)) {
+      for (const middleware of registration.middleware) {
+        const result = await this.runMiddlewareHandler(registration, middleware, current, context);
+        if (result === undefined)
+          continue;
+        if (isHookControlResult(result)) {
+          current = result.payload;
+          if (result.type === "stop")
+            return { payload: current };
+          continue;
+        }
+        if (isRunStopControlResult(result))
+          return { payload: current, control: result };
+        current = result;
+      }
+    }
+    return { payload: current };
+  }
+  async runObservers(name, payload, context) {
+    for (const registration of this.matchingRegistrations(name, payload)) {
+      for (const observer of registration.observers) {
+        const task = this.runObserverHandler(registration, observer, payload, context);
+        if (registration.descriptor.mode === "async") {
+          task.catch(() => {});
+          continue;
+        }
+        await task.catch(() => {});
+      }
+    }
+  }
+  matchingRegistrations(name, payload) {
+    return this.registrations.filter((registration) => {
+      return registration.descriptor.name === name && matchesHookDescriptor(registration.descriptor, payload);
+    });
+  }
+  async runMiddlewareHandler(registration, middleware, payload, context) {
+    const task = Promise.resolve(middleware({
+      payload,
+      context: this.withHandlerMetadata(context, registration)
+    }));
+    return await withTimeout(task, registration.descriptor.timeoutMs, () => {
+      return new Error(`Hook ${registration.descriptor.name} for plugin ${registration.pluginId} timed out after ${registration.descriptor.timeoutMs}ms`);
+    });
+  }
+  async runObserverHandler(registration, observer, payload, context) {
+    const task = Promise.resolve(observer({
+      payload,
+      context: this.withHandlerMetadata(context, registration)
+    }));
+    await withTimeout(task, registration.descriptor.timeoutMs, () => {
+      return new Error(`Hook ${registration.descriptor.name} for plugin ${registration.pluginId} timed out after ${registration.descriptor.timeoutMs}ms`);
+    });
+  }
+  withHandlerMetadata(context, registration) {
+    return {
+      ...context,
+      services: registration.services ?? context.services,
+      status: context.status ? structuredClone(context.status) : undefined,
+      metadata: {
+        ...context.metadata,
+        pluginId: registration.pluginId,
+        hookName: registration.descriptor.name
+      }
+    };
+  }
+}
+function matchesHookDescriptor(descriptor, payload) {
+  const matcher = descriptor.when;
+  if (!matcher)
+    return true;
+  if (matcher.toolName && !matchesValue(matcher.toolName, readToolName(payload)))
+    return false;
+  if (matcher.notificationType && !matchesValue(matcher.notificationType, readNotificationType(payload)))
+    return false;
+  if (matcher.stopReason && !matchesValue(matcher.stopReason, readStopReason(payload)))
+    return false;
+  if (matcher.source && !matchesValue(matcher.source, readSource(payload)))
+    return false;
+  return true;
+}
+function readToolName(payload) {
+  if ("toolCall" in payload)
+    return payload.toolCall.function.name;
+  return;
+}
+function readNotificationType(payload) {
+  if ("notification" in payload)
+    return payload.notification.type;
+  return;
+}
+function readStopReason(payload) {
+  if ("stopReason" in payload)
+    return payload.stopReason;
+  return;
+}
+function readSource(payload) {
+  if ("notification" in payload)
+    return payload.notification.source;
+  return;
+}
+function matchesValue(expected, actual) {
+  if (!actual)
+    return false;
+  if (Array.isArray(expected))
+    return expected.includes(actual);
+  return expected === actual;
+}
+async function withTimeout(promise, timeoutMs, createError) {
+  if (!timeoutMs || timeoutMs <= 0)
+    return await promise;
+  let timeoutHandle;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => reject(createError()), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutHandle)
+      clearTimeout(timeoutHandle);
+  }
+}
+
+// src/plugin-host/plugin-host.ts
+class PluginHost {
+  pipeline = new HookPipeline;
+  contextContributors = [];
+  promptContributors = [];
+  tools = [];
+  sessionControllerFactories = [];
+  services;
+  cwd;
+  agentId;
+  tracker;
+  constructor(options) {
+    this.agentId = options.agentId;
+    this.cwd = options.cwd;
+    this.services = options.services;
+    this.tracker = options.tracker;
+    for (const plugin of options.plugins ?? []) {
+      const priority = plugin.manifest.priority ?? 0;
+      const scopedServices = options.permissionGateway.scopeServices(this.services, plugin.manifest.id, plugin.manifest.permissions);
+      const setup = plugin.setup?.({
+        cwd: this.cwd,
+        manifest: plugin.manifest,
+        services: scopedServices
+      });
+      this.pipeline.register(plugin.manifest.id, priority, setup?.hooks, scopedServices);
+      for (const tool of setup?.tools ?? []) {
+        this.tools.push({
+          pluginId: plugin.manifest.id,
+          tool: wrapTool(plugin.manifest.id, tool, scopedServices)
+        });
+      }
+      for (const contributor of setup?.contextContributors ?? [])
+        this.contextContributors.push({ pluginId: plugin.manifest.id, contributor });
+      for (const contributor of setup?.promptContributors ?? [])
+        this.promptContributors.push({ pluginId: plugin.manifest.id, contributor });
+      if (setup?.createSessionController) {
+        this.sessionControllerFactories.push({
+          pluginId: plugin.manifest.id,
+          factory: setup.createSessionController,
+          services: scopedServices
+        });
+      }
+    }
+  }
+  pluginTools() {
+    return this.tools.map((entry) => entry.tool);
+  }
+  recentFiles(limit = 5) {
+    return this.tracker?.recentFiles(limit) ?? [];
+  }
+  createSessionControllers(input) {
+    const controllers = new Map;
+    for (const entry of this.sessionControllerFactories) {
+      controllers.set(entry.pluginId, entry.factory({
+        sessionId: input.sessionId,
+        metadata: input.metadata ? structuredClone(input.metadata) : undefined,
+        getStatus: input.getStatus,
+        pluginState: entry.services.pluginState,
+        save: input.save,
+        isRunning: input.isRunning
+      }));
+    }
+    return controllers;
+  }
+  async runMiddleware(name, payload, context = {}) {
+    return this.pipeline.runMiddleware(name, payload, this.createRuntimeContext(context));
+  }
+  async runToolBeforeExecute(payload, context = {}) {
+    return this.pipeline.runToolBeforeExecute(payload, this.createRuntimeContext(context));
+  }
+  async runNotifyMessage(payload, context = {}) {
+    return this.pipeline.runNotifyMessage(payload, this.createRuntimeContext(context));
+  }
+  async runRunStop(payload, context = {}) {
+    return this.pipeline.runRunStop(payload, this.createRuntimeContext(context));
+  }
+  async runObservers(name, payload, context = {}) {
+    await this.pipeline.runObservers(name, payload, this.createRuntimeContext(context));
+  }
+  async collectContext(input) {
+    const items = [];
+    for (const entry of this.contextContributors) {
+      const next = await entry.contributor(input);
+      if (next.length > 0)
+        items.push(...next);
+    }
+    return items;
+  }
+  async collectPromptSegments(input) {
+    const segments = [];
+    for (const entry of this.promptContributors) {
+      const next = await entry.contributor(input);
+      if (!next)
+        continue;
+      if (Array.isArray(next))
+        segments.push(...next.filter(Boolean));
+      else
+        segments.push(next);
+    }
+    return segments;
+  }
+  createRuntimeContext(context) {
+    return {
+      agentId: this.agentId,
+      cwd: context.cwd ?? this.cwd,
+      sessionId: context.sessionId,
+      requestId: context.requestId,
+      iteration: context.iteration,
+      status: context.status ? structuredClone(context.status) : undefined,
+      metadata: context.metadata,
+      services: context.services ?? this.services
+    };
+  }
+}
+function wrapTool(pluginId, tool, services) {
+  return {
+    definition: tool.definition,
+    async execute(args, context) {
+      return tool.execute(args, {
+        ...context,
+        metadata: {
+          ...context.metadata,
+          pluginId
+        },
+        emitEvent: (event) => context.emitEvent?.({
+          ...event,
+          pluginId: event.pluginId ?? pluginId
+        }),
+        services
+      });
+    }
+  };
+}
+
+// src/services/activity.ts
+class ActivityTracker {
+  records = [];
+  record(record) {
+    this.records.push({ ...record, timestamp: record.timestamp });
+    if (this.records.length > 200)
+      this.records.splice(0, this.records.length - 200);
+  }
+  recentFiles(limit = 5) {
+    const seen = new Set;
+    const files = [];
+    for (let index = this.records.length - 1;index >= 0; index -= 1) {
+      const record = this.records[index];
+      if (!record || record.type !== "file")
+        continue;
+      if (seen.has(record.label))
+        continue;
+      seen.add(record.label);
+      files.push(record.label);
+      if (files.length >= limit)
+        break;
+    }
+    return files;
+  }
+}
+// src/services/exec-gateway.ts
+import { spawn } from "node:child_process";
+
+class NodeExecGateway {
+  cwd;
+  env;
+  tracker;
+  constructor(options = {}) {
+    this.cwd = options.cwd;
+    this.env = options.env ?? process.env;
+    this.tracker = options.tracker;
+  }
+  async execute(command, options = {}) {
+    const cwd = options.cwd ?? this.cwd;
+    const env = {
+      ...this.env,
+      ...options.env
+    };
+    const result = await new Promise((resolve, reject) => {
+      const child = spawn(command, {
+        cwd,
+        env,
+        shell: true,
+        signal: options.signal
+      });
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      let timedOut = false;
+      let timeout;
+      const finish = (value, isError) => {
+        if (settled)
+          return;
+        settled = true;
+        if (timeout)
+          clearTimeout(timeout);
+        if (isError)
+          reject(value);
+        else
+          resolve(value);
+      };
+      if (options.timeoutMs !== undefined) {
+        timeout = setTimeout(() => {
+          timedOut = true;
+          child.kill("SIGTERM");
+        }, options.timeoutMs);
+      }
+      child.stdout.on("data", (chunk) => {
+        stdout += String(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+      child.on("error", (error) => finish(error, true));
+      child.on("close", (code, signal) => {
+        finish({
+          command,
+          cwd: cwd ?? null,
+          stdout,
+          stderr,
+          exitCode: code,
+          signal: signal ?? null,
+          timedOut
+        }, false);
+      });
+    });
+    this.tracker?.record({
+      type: "command",
+      label: command,
+      timestamp: Date.now()
+    });
+    return result;
+  }
+}
+// src/services/file-system-gateway.ts
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+
+class NodeFileSystemGateway {
+  cwd;
+  tracker;
+  constructor(options = {}) {
+    this.cwd = options.cwd;
+    this.tracker = options.tracker;
+  }
+  async readText(targetPath, options = {}) {
+    const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+    const text = await readFile(resolved, "utf8");
+    this.recordFile(resolved);
+    return text;
+  }
+  async writeText(targetPath, content, options = {}) {
+    const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+    await mkdir(path2.dirname(resolved), { recursive: true });
+    await writeFile(resolved, content, "utf8");
+    this.recordFile(resolved);
+    return {
+      path: resolved,
+      bytes: Buffer.byteLength(content, "utf8")
+    };
+  }
+  async editText(targetPath, options) {
+    const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+    const source = await readFile(resolved, "utf8");
+    const matches = source.split(options.oldText).length - 1;
+    if (matches === 0)
+      throw new Error("oldText was not found in the target file");
+    if (!options.replaceAll && matches > 1)
+      throw new Error("oldText matched more than once; set replaceAll to true to replace all matches");
+    const updated = options.replaceAll ? source.split(options.oldText).join(options.newText) : source.replace(options.oldText, options.newText);
+    await writeFile(resolved, updated, "utf8");
+    this.recordFile(resolved);
+    return {
+      path: resolved,
+      replacements: options.replaceAll ? matches : 1
+    };
+  }
+  async exists(targetPath, options = {}) {
+    try {
+      const resolved = resolvePath(this.cwd, targetPath, options.cwd);
+      await stat(resolved);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async glob(pattern, options = {}) {
+    const root = path2.resolve(options.cwd ?? this.cwd ?? process.cwd());
+    const matcher = compileGlob(pattern);
+    const limit = options.limit ?? 100;
+    const matches = [];
+    await walk(root, root, async (absolutePath, relativePath) => {
+      if (matches.length >= limit)
+        return false;
+      if (matcher.test(relativePath))
+        matches.push(absolutePath);
+      return true;
+    });
+    return matches;
+  }
+  async grep(query, options = {}) {
+    const pattern = options.pattern ?? "**/*";
+    const files = await this.glob(pattern, options);
+    const matches = [];
+    const limit = options.limit ?? 50;
+    for (const filePath of files) {
+      if (matches.length >= limit)
+        break;
+      let text;
+      try {
+        text = await readFile(filePath, "utf8");
+      } catch {
+        continue;
+      }
+      const lines = text.split(/\r?\n/g);
+      for (let index = 0;index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line || !line.includes(query))
+          continue;
+        matches.push({
+          path: filePath,
+          lineNumber: index + 1,
+          line
+        });
+        if (matches.length >= limit)
+          break;
+      }
+    }
+    return matches;
+  }
+  recordFile(filePath) {
+    this.tracker?.record({
+      type: "file",
+      label: filePath,
+      timestamp: Date.now()
+    });
+  }
+}
+function resolvePath(defaultCwd, targetPath, cwdOverride) {
+  if (!targetPath.trim())
+    throw new Error("path is required");
+  if (path2.isAbsolute(targetPath))
+    return path2.normalize(targetPath);
+  return path2.resolve(cwdOverride ?? defaultCwd ?? process.cwd(), targetPath);
+}
+function compileGlob(pattern) {
+  const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+  let expression = "^";
+  for (let index = 0;index < normalized.length; index += 1) {
+    const character = normalized[index];
+    const next = normalized[index + 1];
+    if (character === "*" && next === "*") {
+      expression += ".*";
+      index += 1;
+      continue;
+    }
+    if (character === "*") {
+      expression += "[^/]*";
+      continue;
+    }
+    expression += /[.+^${}()|[\]\\]/.test(character) ? `\\${character}` : character;
+  }
+  expression += "$";
+  return new RegExp(expression);
+}
+async function walk(root, current, visit) {
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git")
+      continue;
+    const absolutePath = path2.join(current, entry.name);
+    const relativePath = path2.relative(root, absolutePath).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const keepGoing = await visit(absolutePath, relativePath);
+      if (keepGoing !== false)
+        await walk(root, absolutePath, visit);
+      continue;
+    }
+    await visit(absolutePath, relativePath);
+  }
+}
+// src/services/git-gateway.ts
+class DefaultGitGateway {
+  exec;
+  cwd;
+  constructor(options) {
+    this.exec = options.exec;
+    this.cwd = options.cwd;
+  }
+  async status(options = {}) {
+    return this.runGitCommand("git status --short", options.cwd);
+  }
+  async diff(options = {}) {
+    return this.runGitCommand('git diff --stat && printf "\\n---\\n" && git diff -- .', options.cwd);
+  }
+  async runGitCommand(command, cwd) {
+    try {
+      const result = await this.exec.execute(command, { cwd: cwd ?? this.cwd, timeoutMs: 1e4 });
+      if (result.exitCode !== 0)
+        return null;
+      const text = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? `
+` : "");
+      return text.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+}
+// src/services/model-gateway.ts
+class DefaultModelGateway {
+  model;
+  constructor(model) {
+    this.model = model;
+  }
+  stream(request) {
+    return this.model.stream(request);
+  }
+}
+// src/services/network-gateway.ts
+class DefaultNetworkGateway {
+  fetchImpl;
+  constructor(fetchImpl = globalThis.fetch) {
+    this.fetchImpl = fetchImpl;
+  }
+  fetch(input, init) {
+    return this.fetchImpl(input, init);
+  }
+}
+// src/services/permissions.ts
+var fullPermissions = {
+  fs: "full",
+  git: true,
+  network: true,
+  process: true,
+  model: true,
+  mcp: true
+};
+
+class PermissionDeniedError extends Error {
+  code = "permission_denied";
+  constructor(message) {
+    super(message);
+    this.name = "PermissionDeniedError";
+  }
+}
+function normalizePermissions(input) {
+  return {
+    ...fullPermissions,
+    ...input
+  };
+}
+function canReadFs(permissions) {
+  return permissions.fs === true || permissions.fs === "read" || permissions.fs === "full";
+}
+function canWriteFs(permissions) {
+  return permissions.fs === true || permissions.fs === "write" || permissions.fs === "full";
+}
+// src/services/permission-gateway.ts
+class PermissionGateway {
+  permissions;
+  compactionOwnerPluginId;
+  constructor(options = {}) {
+    this.permissions = normalizePermissions(options.permissions);
+    this.compactionOwnerPluginId = options.compactionOwnerPluginId;
+  }
+  get agentPermissions() {
+    return { ...this.permissions };
+  }
+  scopeServices(services, pluginId, requested) {
+    const effective = intersectPermissions(this.permissions, requested);
+    const pluginState = services.pluginState;
+    return {
+      fileSystem: {
+        readText: (path3, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to read files`);
+          return services.fileSystem.readText(path3, options);
+        },
+        writeText: (path3, content, options) => {
+          if (!canWriteFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to write files`);
+          return services.fileSystem.writeText(path3, content, options);
+        },
+        editText: (path3, options) => {
+          if (!canWriteFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to edit files`);
+          return services.fileSystem.editText(path3, options);
+        },
+        exists: (path3, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to inspect files`);
+          return services.fileSystem.exists(path3, options);
+        },
+        glob: (pattern, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to glob files`);
+          return services.fileSystem.glob(pattern, options);
+        },
+        grep: (query, options) => {
+          if (!canReadFs(effective))
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to grep files`);
+          return services.fileSystem.grep(query, options);
+        }
+      },
+      exec: {
+        execute: (command, options) => {
+          if (effective.process !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to execute commands`);
+          return services.exec.execute(command, options);
+        }
+      },
+      git: {
+        status: (options) => {
+          if (effective.git !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to inspect git state`);
+          return services.git.status(options);
+        },
+        diff: (options) => {
+          if (effective.git !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to inspect git diff`);
+          return services.git.diff(options);
+        }
+      },
+      network: {
+        fetch: (input, init) => {
+          if (effective.network !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to access the network`);
+          return services.network.fetch(input, init);
+        }
+      },
+      model: {
+        stream: (request) => {
+          if (effective.model !== true)
+            throw new PermissionDeniedError(`Plugin ${pluginId} is not allowed to call the model gateway`);
+          return services.model.stream(request);
+        }
+      },
+      compaction: {
+        getState: (sessionId) => services.compaction.getState(sessionId),
+        apply: (update) => {
+          this.ensureCompactionOwner(pluginId);
+          return services.compaction.apply(update);
+        },
+        clear: (sessionId) => {
+          this.ensureCompactionOwner(pluginId);
+          return services.compaction.clear(sessionId);
+        }
+      },
+      pluginState: {
+        get: (sessionId) => pluginState.getForPlugin(sessionId, pluginId),
+        replace: (sessionId, entry) => pluginState.replaceForPlugin(sessionId, pluginId, entry),
+        clear: (sessionId) => pluginState.clearForPlugin(sessionId, pluginId)
+      }
+    };
+  }
+  ensureCompactionOwner(pluginId) {
+    if (this.compactionOwnerPluginId === pluginId)
+      return;
+    const message = this.compactionOwnerPluginId ? `Plugin ${pluginId} is not the configured compaction owner (${this.compactionOwnerPluginId})` : `Plugin ${pluginId} cannot modify canonical compaction without compaction.ownerPluginId`;
+    const error = new Error(message);
+    error.code = "compaction_owner_required";
+    throw error;
+  }
+}
+function intersectPermissions(agent, requested) {
+  const normalized = requested ?? {};
+  return {
+    fs: intersectFs(agent.fs, normalized.fs ?? false),
+    git: agent.git === true && normalized.git === true,
+    network: agent.network === true && normalized.network === true,
+    process: agent.process === true && normalized.process === true,
+    model: agent.model === true && normalized.model === true,
+    mcp: agent.mcp === true && normalized.mcp === true
+  };
+}
+function intersectFs(left, right) {
+  const rank = new Map([
+    [false, 0],
+    ["read", 1],
+    ["write", 1],
+    [true, 2],
+    ["full", 2]
+  ]);
+  const leftValue = left ?? false;
+  const rightValue = right ?? false;
+  if (leftValue === "full" || leftValue === true)
+    return rightValue;
+  if (rightValue === "full" || rightValue === true)
+    return leftValue;
+  if (leftValue === rightValue)
+    return leftValue;
+  if (rank.get(leftValue) === 0 || rank.get(rightValue) === 0)
+    return false;
+  if (leftValue === "read" && rightValue === "write" || leftValue === "write" && rightValue === "read")
+    return false;
+  return leftValue;
+}
+// src/contracts/tool-normalize.ts
+function normalizeToolSchema(schema) {
+  if (!isRecord(schema) || schema.type !== "object")
+    throw new TypeError('Tool input schema must have type "object"');
+  const properties = schema.properties;
+  if (properties !== undefined && !isRecord(properties))
+    throw new TypeError("Tool input schema properties must be an object");
+  const required = schema.required;
+  if (required !== undefined && !isStringArray(required))
+    throw new TypeError("Tool input schema required must be a string array");
+  const normalized = {
+    ...schema,
+    type: "object",
+    properties: properties ? cloneSchemaRecord(properties) : {}
+  };
+  return normalized;
+}
+function cloneSchemaRecord(record) {
+  return Object.fromEntries(Object.entries(record).map(([key, value]) => {
+    if (!isRecord(value))
+      throw new TypeError(`Tool schema property ${key} must be an object`);
+    return [key, { ...value }];
+  }));
+}
+function normalizeToolResult(result) {
+  const normalized = {
+    content: normalizeContent(result.content),
+    isError: result.isError === true
+  };
+  if (result.structuredContent !== undefined) {
+    assertJsonSafeObject(result.structuredContent, "Tool structuredContent");
+    normalized.structuredContent = { ...result.structuredContent };
+  }
+  return normalized;
+}
+
+// src/tools/base-tool.ts
+class BaseTool {
+  definition;
+  constructor(definition) {
+    this.definition = {
+      ...definition,
+      inputSchema: normalizeToolSchema(definition.inputSchema)
+    };
+  }
+}
+// src/tools/result.ts
+function textToolResult(text) {
+  return {
+    content: normalizeContent(text)
+  };
+}
+// src/tools/tool-registry.ts
+class ToolRegistry {
+  tools = new Map;
+  register(tool) {
+    const name = tool.definition.name.trim();
+    if (!name)
+      throw new Error("Tool name is required");
+    if (this.tools.has(name))
+      throw new Error(`Tool already registered: ${name}`);
+    const normalizedDefinition = {
+      ...tool.definition,
+      name,
+      description: tool.definition.description.trim(),
+      inputSchema: normalizeToolSchema(tool.definition.inputSchema)
+    };
+    const normalizedTool = {
+      definition: normalizedDefinition,
+      execute(args, context) {
+        return tool.execute(args, context);
+      }
+    };
+    this.tools.set(name, normalizedTool);
+    return this;
+  }
+  unregister(name) {
+    return this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  list() {
+    return [...this.tools.values()];
+  }
+  definitions() {
+    return this.list().map((tool) => ({
+      ...tool.definition,
+      inputSchema: normalizeToolSchema(tool.definition.inputSchema)
+    }));
+  }
+}
+// src/tools/builtins/utils.ts
+function readStringArg(args, key, options = {}) {
+  const value = args[key];
+  if (typeof value !== "string")
+    throw new Error(`${key} must be a string`);
+  if (!options.allowEmpty && value.length === 0)
+    throw new Error(`${key} must be a non-empty string`);
+  return value;
+}
+function readOptionalBooleanArg(args, key) {
+  const value = args[key];
+  if (value === undefined)
+    return;
+  if (typeof value !== "boolean")
+    throw new Error(`${key} must be a boolean`);
+  return value;
+}
+function readOptionalNumberArg(args, key) {
+  const value = args[key];
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new Error(`${key} must be a finite number`);
+  return value;
+}
+
+// src/tools/builtins/edit-tool.ts
+class EditTool extends BaseTool {
+  constructor() {
+    super({
+      name: "edit",
+      description: "Replace text in a UTF-8 file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path to edit." },
+          oldText: { type: "string", description: "Text to replace." },
+          newText: { type: "string", description: "Replacement text." },
+          replaceAll: { type: "boolean", description: "Replace all matches when true." }
+        },
+        required: ["path", "oldText", "newText"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const fileSystem = context.services?.fileSystem;
+    if (!fileSystem)
+      throw new Error("FileSystemGateway is not available in the tool execution context");
+    const targetPath = readStringArg(args, "path");
+    const oldText = readStringArg(args, "oldText");
+    const newText = readStringArg(args, "newText", { allowEmpty: true });
+    const replaceAll = readOptionalBooleanArg(args, "replaceAll") ?? false;
+    const result = await fileSystem.editText(targetPath, {
+      oldText,
+      newText,
+      replaceAll,
+      cwd: context.cwd
+    });
+    return normalizeToolResult({
+      content: [{ type: "text", text: `Edited ${result.path}` }],
+      structuredContent: result
+    });
+  }
+}
+// src/tools/builtins/exec-tool.ts
+class ExecTool extends BaseTool {
+  constructor() {
+    super({
+      name: "exec",
+      description: "Execute a shell command.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute." },
+          cwd: { type: "string", description: "Optional working directory override." },
+          timeoutMs: { type: "number", description: "Optional timeout in milliseconds." }
+        },
+        required: ["command"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const exec = context.services?.exec;
+    if (!exec)
+      throw new Error("ExecGateway is not available in the tool execution context");
+    const command = readStringArg(args, "command");
+    const cwd = typeof args.cwd === "string" && args.cwd.length > 0 ? args.cwd : context.cwd;
+    const timeoutMs = readOptionalNumberArg(args, "timeoutMs");
+    const result = await exec.execute(command, {
+      cwd,
+      timeoutMs,
+      signal: context.signal
+    });
+    const text = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? `
+` : "");
+    return normalizeToolResult({
+      content: [{ type: "text", text: text || `Command exited with code ${result.exitCode ?? -1}` }],
+      structuredContent: { ...result },
+      isError: result.exitCode !== 0
+    });
+  }
+}
+// src/tools/builtins/read-tool.ts
+class ReadTool extends BaseTool {
+  constructor() {
+    super({
+      name: "read",
+      description: "Read a UTF-8 text file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path to read." }
+        },
+        required: ["path"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const fileSystem = context.services?.fileSystem;
+    if (!fileSystem)
+      throw new Error("FileSystemGateway is not available in the tool execution context");
+    const targetPath = readStringArg(args, "path");
+    const text = await fileSystem.readText(targetPath, { cwd: context.cwd });
+    return normalizeToolResult({
+      content: [{ type: "text", text }],
+      structuredContent: {
+        path: targetPath,
+        size: Buffer.byteLength(text, "utf8")
+      }
+    });
+  }
+}
+// src/tools/builtins/write-tool.ts
+class WriteTool extends BaseTool {
+  constructor() {
+    super({
+      name: "write",
+      description: "Write a UTF-8 text file.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "File path to write." },
+          content: { type: "string", description: "Text content to write." }
+        },
+        required: ["path", "content"]
+      }
+    });
+  }
+  async execute(args, context) {
+    const fileSystem = context.services?.fileSystem;
+    if (!fileSystem)
+      throw new Error("FileSystemGateway is not available in the tool execution context");
+    const targetPath = readStringArg(args, "path");
+    const content = readStringArg(args, "content", { allowEmpty: true });
+    const result = await fileSystem.writeText(targetPath, content, { cwd: context.cwd });
+    return normalizeToolResult({
+      content: [{ type: "text", text: `Wrote ${result.path}` }],
+      structuredContent: result
+    });
+  }
+}
+// src/agent-core/approvals.ts
+class DefaultApprovalManager {
+  handler;
+  notifications;
+  constructor(options = {}) {
+    this.handler = options.handler;
+    this.notifications = options.notifications;
+  }
+  async requestApproval(request, context) {
+    const normalizedRequest = {
+      ...request,
+      id: request.id ?? createId("approval")
+    };
+    await this.notifications?.emit({
+      type: "approval.requested",
+      source: "approval",
+      level: "warning",
+      message: normalizedRequest.message,
+      metadata: {
+        approvalId: normalizedRequest.id,
+        toolName: normalizedRequest.toolCall.function.name
+      }
+    }, context);
+    if (!this.handler) {
+      const denied = {
+        type: "denied",
+        reason: "No approval handler configured"
+      };
+      await this.notifications?.emit({
+        type: "approval.denied",
+        source: "approval",
+        level: "warning",
+        message: denied.reason,
+        metadata: {
+          approvalId: normalizedRequest.id,
+          toolName: normalizedRequest.toolCall.function.name
+        }
+      }, context);
+      return denied;
+    }
+    const decision = await this.handler(normalizedRequest);
+    await this.notifications?.emit({
+      type: decision.type === "approved" ? "approval.approved" : "approval.denied",
+      source: "approval",
+      level: decision.type === "approved" ? "info" : "warning",
+      message: decision.type === "approved" ? `Approved tool call: ${normalizedRequest.toolCall.function.name}` : decision.reason ?? `Denied tool call: ${normalizedRequest.toolCall.function.name}`,
+      metadata: {
+        approvalId: normalizedRequest.id,
+        toolName: normalizedRequest.toolCall.function.name
+      }
+    }, context);
+    return decision;
+  }
+}
+
+// src/agent-core/session-state.ts
+function touchRuntimeSessionState(state) {
+  state.updatedAt = Date.now();
+}
+
+// src/agent-core/compaction.ts
+function createEmptyCompactionState() {
+  return {
+    cursor: 0,
+    systemSegments: [],
+    checkpoints: []
+  };
+}
+function cloneCompactionState(state) {
+  if (!state)
+    return createEmptyCompactionState();
+  return structuredClone({
+    cursor: state.cursor,
+    systemSegments: [...state.systemSegments],
+    checkpoints: state.checkpoints.map((checkpoint) => ({
+      ...checkpoint,
+      systemSegments: [...checkpoint.systemSegments],
+      metadata: checkpoint.metadata ? structuredClone(checkpoint.metadata) : undefined
+    }))
+  });
+}
+function normalizeCompactionState(state, messages) {
+  const current = cloneCompactionState(state);
+  return {
+    cursor: clampCursor(current.cursor, messages.length),
+    systemSegments: current.systemSegments.filter(Boolean),
+    checkpoints: current.checkpoints.map((checkpoint) => ({
+      ...checkpoint,
+      cursor: clampCursor(checkpoint.cursor, messages.length),
+      systemSegments: checkpoint.systemSegments.filter(Boolean)
+    }))
+  };
+}
+function applyCompactionUpdate(state, update) {
+  const nextCursor = clampCursor(update.cursor, state.messages.length);
+  const nextSystemSegments = [...update.systemSegments ?? state.compaction.systemSegments].filter(Boolean);
+  const nextCheckpoint = {
+    id: createId("compact"),
+    cursor: nextCursor,
+    systemSegments: nextSystemSegments,
+    summary: update.summary,
+    reason: update.reason ?? "manual",
+    createdAt: Date.now(),
+    metadata: update.metadata ? structuredClone(update.metadata) : undefined
+  };
+  state.compaction = {
+    cursor: nextCursor,
+    systemSegments: nextSystemSegments,
+    checkpoints: [...state.compaction.checkpoints, nextCheckpoint]
+  };
+  touchRuntimeSessionState(state);
+  return cloneCompactionState(state.compaction);
+}
+function clearCompactionState(state) {
+  state.compaction = createEmptyCompactionState();
+  touchRuntimeSessionState(state);
+  return cloneCompactionState(state.compaction);
+}
+function projectMessagesForRequest(messages, compaction) {
+  const leadingSystemMessages = readLeadingSystemMessages(messages);
+  const startIndex = Math.max(compaction.cursor, leadingSystemMessages.length);
+  return [
+    ...leadingSystemMessages,
+    ...messages.slice(startIndex)
+  ];
+}
+function buildCompactionPromptSegments(compaction) {
+  return compaction.systemSegments.filter(Boolean);
+}
+function calculateThresholdTokens(options) {
+  if (options.triggerTokens !== undefined)
+    return options.triggerTokens;
+  const ratio = options.triggerRatio ?? 0.8;
+  return Math.max(1, Math.floor(options.maxInputTokens * ratio));
+}
+async function estimateCompactionBudget(options, input) {
+  const estimatedInputTokens = options.estimator ? await options.estimator(input) : estimateByHeuristic(input);
+  return {
+    estimatedInputTokens,
+    thresholdTokens: calculateThresholdTokens(options),
+    maxInputTokens: options.maxInputTokens
+  };
+}
+function isCompactionRequired(options, budget) {
+  if (!options || options.enabled === false || !budget)
+    return false;
+  return budget.estimatedInputTokens >= budget.thresholdTokens;
+}
+function didCompactionStateChange(before, after) {
+  return before.cursor !== after.cursor || JSON.stringify(before.systemSegments) !== JSON.stringify(after.systemSegments) || before.checkpoints.length !== after.checkpoints.length;
+}
+
+class DefaultCompactionService {
+  sessions = new Map;
+  registerSession(state) {
+    state.compaction = normalizeCompactionState(state.compaction, state.messages);
+    this.sessions.set(state.id, state);
+  }
+  unregisterSession(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  async getState(sessionId) {
+    return cloneCompactionState(this.requireSession(sessionId).compaction);
+  }
+  async apply(update) {
+    return applyCompactionUpdate(this.requireSession(update.sessionId), update);
+  }
+  async clear(sessionId) {
+    return clearCompactionState(this.requireSession(sessionId));
+  }
+  requireSession(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state)
+      throw new Error(`Unknown session for compaction: ${sessionId}`);
+    return state;
+  }
+}
+function clampCursor(cursor, max) {
+  if (!Number.isFinite(cursor))
+    return 0;
+  return Math.max(0, Math.min(Math.floor(cursor), max));
+}
+function readLeadingSystemMessages(messages) {
+  const systemMessages = [];
+  for (const message of messages) {
+    if (message.role !== "system")
+      break;
+    systemMessages.push(message);
+  }
+  return systemMessages;
+}
+function estimateByHeuristic(input) {
+  const messageChars = input.messages.reduce((total, message) => {
+    const contentChars = JSON.stringify(message.content).length;
+    const metadataChars = message.metadata ? JSON.stringify(message.metadata).length : 0;
+    return total + message.role.length + contentChars + metadataChars;
+  }, 0);
+  const toolChars = input.tools ? JSON.stringify(input.tools).length : 0;
+  const modelChars = `${input.model.provider}:${input.model.modelId}`.length;
+  return Math.max(1, Math.ceil((messageChars + toolChars + modelChars) / 4));
+}
+
+// src/agent-core/plugin-state.ts
+var APP_PLUGIN_NAMESPACE = "__agent__";
+function clonePluginSessionStateEntry(entry) {
+  if (!entry)
+    return null;
+  return structuredClone({
+    version: entry.version,
+    data: structuredClone(entry.data),
+    updatedAt: entry.updatedAt
+  });
+}
+function clonePluginStateMap(state) {
+  if (!state)
+    return {};
+  return Object.fromEntries(Object.entries(state).map(([pluginId, entry]) => [pluginId, clonePluginSessionStateEntry(entry)]));
+}
+function normalizePluginStateMap(state) {
+  if (!state)
+    return {};
+  return Object.fromEntries(Object.entries(state).map(([pluginId, entry]) => [pluginId, normalizePluginSessionStateEntry(entry, `Plugin session state for ${pluginId}`)]));
+}
+
+class DefaultPluginStateService {
+  sessions = new Map;
+  registerSession(state) {
+    state.pluginState = normalizePluginStateMap(state.pluginState);
+    this.sessions.set(state.id, state);
+  }
+  unregisterSession(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  async get(sessionId) {
+    return this.getForPlugin(sessionId, APP_PLUGIN_NAMESPACE);
+  }
+  async replace(sessionId, entry) {
+    return this.replaceForPlugin(sessionId, APP_PLUGIN_NAMESPACE, entry);
+  }
+  async clear(sessionId) {
+    await this.clearForPlugin(sessionId, APP_PLUGIN_NAMESPACE);
+  }
+  async getForPlugin(sessionId, pluginId) {
+    const state = this.requireSession(sessionId);
+    return clonePluginSessionStateEntry(state.pluginState[pluginId]);
+  }
+  async replaceForPlugin(sessionId, pluginId, entry) {
+    const state = this.requireSession(sessionId);
+    const nextEntry = normalizePluginSessionStateEntry(entry, `Plugin session state for ${pluginId}`);
+    state.pluginState = {
+      ...state.pluginState,
+      [pluginId]: nextEntry
+    };
+    touchRuntimeSessionState(state);
+    return clonePluginSessionStateEntry(nextEntry);
+  }
+  async clearForPlugin(sessionId, pluginId) {
+    const state = this.requireSession(sessionId);
+    if (!(pluginId in state.pluginState))
+      return;
+    const nextState = { ...state.pluginState };
+    delete nextState[pluginId];
+    state.pluginState = nextState;
+    touchRuntimeSessionState(state);
+  }
+  async list(sessionId) {
+    return clonePluginStateMap(this.requireSession(sessionId).pluginState);
+  }
+  requireSession(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state)
+      throw new Error(`Unknown session for plugin state: ${sessionId}`);
+    return state;
+  }
+}
+function normalizePluginSessionStateEntry(entry, label) {
+  if (!Number.isFinite(entry.version))
+    throw new TypeError(`${label} version must be a finite number`);
+  if (!Number.isFinite(entry.updatedAt))
+    throw new TypeError(`${label} updatedAt must be a finite number`);
+  assertJsonSafeObject(entry.data, `${label} data`);
+  return {
+    version: Math.floor(entry.version),
+    data: structuredClone(entry.data),
+    updatedAt: entry.updatedAt
+  };
+}
+
+// src/agent-core/message-factory.ts
+class DefaultMessageFactory {
+  createSystemMessage(input) {
+    return {
+      id: createId("msg"),
+      role: "system",
+      content: normalizeContent(input),
+      createdAt: Date.now()
+    };
+  }
+  createUserMessage(input) {
+    return {
+      id: createId("msg"),
+      role: "user",
+      content: normalizeContent(input),
+      createdAt: Date.now()
+    };
+  }
+  createAssistantMessage(input) {
+    return {
+      id: createId("msg"),
+      role: "assistant",
+      content: input.text.length > 0 ? normalizeContent(input.text) : [],
+      createdAt: Date.now(),
+      thinking: input.thinking,
+      toolCalls: input.toolCalls.length > 0 ? input.toolCalls : undefined,
+      stopReason: input.stopReason,
+      metadata: input.metadata
+    };
+  }
+  createToolMessage(toolCall, result) {
+    return {
+      id: createId("msg"),
+      role: "tool",
+      content: result.content,
+      createdAt: Date.now(),
+      toolCallId: toolCall.id,
+      toolName: toolCall.function.name,
+      structuredContent: result.structuredContent,
+      isError: result.isError
+    };
+  }
+}
+
+// src/agent-core/notifications.ts
+class DefaultNotificationBus {
+  pluginHost;
+  services;
+  constructor(options) {
+    this.pluginHost = options.pluginHost;
+    this.services = options.services;
+  }
+  async emit(notification, context = {}) {
+    const normalized = {
+      id: notification.id ?? createId("note"),
+      level: notification.level ?? "info",
+      ...notification
+    };
+    if (!this.pluginHost)
+      return normalized;
+    const result = await this.pluginHost.runNotifyMessage({ notification: normalized }, {
+      sessionId: context.sessionId,
+      requestId: context.requestId,
+      iteration: context.iteration,
+      cwd: context.cwd,
+      status: context.status,
+      metadata: context.metadata,
+      services: this.services
+    });
+    if (result.suppressed)
+      return;
+    await this.pluginHost.runObservers("notify.message", result.payload, {
+      sessionId: context.sessionId,
+      requestId: context.requestId,
+      iteration: context.iteration,
+      cwd: context.cwd,
+      status: context.status,
+      metadata: context.metadata,
+      services: this.services
+    });
+    return result.payload.notification;
+  }
+}
+
+// src/persistence/snapshot-codec.ts
+class JsonSnapshotCodec {
+  encode(input) {
+    return structuredClone({
+      schemaVersion: 2,
+      sessionId: input.sessionId,
+      model: input.model,
+      cwd: input.cwd,
+      messages: input.messages,
+      usage: input.usage,
+      compaction: input.compaction,
+      pluginState: input.pluginState,
+      createdAt: input.createdAt,
+      updatedAt: input.updatedAt,
+      metadata: input.metadata,
+      messageQueue: input.messageQueue
+    });
+  }
+  decode(value) {
+    if (!value || typeof value !== "object")
+      throw new TypeError("Session snapshot must be an object");
+    const snapshot = value;
+    if (snapshot.schemaVersion !== 1 && snapshot.schemaVersion !== 2)
+      throw new TypeError("Unsupported session snapshot schemaVersion");
+    if (typeof snapshot.sessionId !== "string")
+      throw new TypeError("Session snapshot sessionId is required");
+    if (!Array.isArray(snapshot.messages))
+      throw new TypeError("Session snapshot messages must be an array");
+    if (typeof snapshot.createdAt !== "number" || typeof snapshot.updatedAt !== "number")
+      throw new TypeError("Session snapshot timestamps are required");
+    if (snapshot.schemaVersion === 1) {
+      return structuredClone({
+        ...snapshot,
+        schemaVersion: 1
+      });
+    }
+    return structuredClone(snapshot);
+  }
+}
+var sessionSnapshotCodec = new JsonSnapshotCodec;
+
+// src/utils/usage.ts
+function createEmptyUsage() {
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0
+  };
+}
+function addUsage(left, right) {
+  if (!right)
+    return { ...left };
+  return {
+    promptTokens: left.promptTokens + right.promptTokens,
+    completionTokens: left.completionTokens + right.completionTokens,
+    totalTokens: left.totalTokens + right.totalTokens
+  };
+}
+
+// src/agent-core/errors.ts
+class SessionExecutionError extends Error {
+  payload;
+  payloadSummary;
+  constructor(payload) {
+    super(payload.message);
+    this.name = "SessionExecutionError";
+    this.payload = payload;
+    this.payloadSummary = stringifyPayload(payload);
+  }
+}
+function stringifyPayload(payload) {
+  try {
+    return JSON.stringify(payload, null, 2);
+  } catch {
+    return String(payload);
+  }
+}
+
+// src/agent-core/tool-call.ts
+function startToolCall(callId, toolName) {
+  if (!callId.trim())
+    throw new Error("Tool call id is required");
+  if (!toolName.trim())
+    throw new Error("Tool name is required");
+  return {
+    callId,
+    toolName,
+    argsText: ""
+  };
+}
+function appendToolCallArgsDelta(draft, delta) {
+  return {
+    ...draft,
+    argsText: `${draft.argsText}${delta}`
+  };
+}
+function finalizeToolCall(draft) {
+  const rawArgumentsText = draft.argsText.trim();
+  const argumentsObject = rawArgumentsText.length === 0 ? {} : parseJsonObject(rawArgumentsText, `Tool call ${draft.callId} arguments`);
+  return {
+    id: draft.callId,
+    type: "function",
+    function: {
+      name: draft.toolName,
+      arguments: argumentsObject
+    },
+    rawArgumentsText
+  };
+}
+
+// src/agent-core/model-turn-collector.ts
+class DefaultModelTurnCollector {
+  async* collect(options) {
+    const assistantTextParts = [];
+    const thinkingParts = [];
+    const toolCalls = [];
+    const drafts = new Map;
+    let stopReason = "final";
+    let responseUsage;
+    let assistantMetadata;
+    for await (const event of options.events) {
+      await options.onEvent?.(event);
+      if (event.type === "response_start")
+        continue;
+      if (event.type === "text_delta") {
+        assistantTextParts.push(event.delta);
+        yield { type: "text_delta", sessionId: options.sessionId, delta: event.delta };
+        continue;
+      }
+      if (event.type === "thinking_delta") {
+        thinkingParts.push(event.delta);
+        yield { type: "thinking_delta", sessionId: options.sessionId, delta: event.delta };
+        continue;
+      }
+      if (event.type === "tool_call_start") {
+        drafts.set(event.callId, startToolCall(event.callId, event.toolName));
+        continue;
+      }
+      if (event.type === "tool_call_args_delta") {
+        const draft = drafts.get(event.callId);
+        if (!draft) {
+          const payload2 = {
+            code: "tool_call_state_error",
+            message: `Received tool_call_args_delta before tool_call_start for ${event.callId}`,
+            requestId: options.requestId
+          };
+          yield { type: "error", sessionId: options.sessionId, error: payload2 };
+          throw new SessionExecutionError(payload2);
+        }
+        drafts.set(event.callId, appendToolCallArgsDelta(draft, event.delta));
+        continue;
+      }
+      if (event.type === "tool_call_end") {
+        const draft = drafts.get(event.callId);
+        if (!draft) {
+          const payload2 = {
+            code: "tool_call_state_error",
+            message: `Received tool_call_end before tool_call_start for ${event.callId}`,
+            requestId: options.requestId
+          };
+          yield { type: "error", sessionId: options.sessionId, error: payload2 };
+          throw new SessionExecutionError(payload2);
+        }
+        try {
+          toolCalls.push(finalizeToolCall(draft));
+        } catch (error) {
+          const payload2 = {
+            code: "tool_call_parse_error",
+            message: error instanceof Error ? error.message : String(error),
+            requestId: options.requestId
+          };
+          yield { type: "error", sessionId: options.sessionId, error: payload2 };
+          throw new SessionExecutionError(payload2);
+        }
+        continue;
+      }
+      if (event.type === "response_end") {
+        stopReason = event.stopReason;
+        responseUsage = event.usage;
+        assistantMetadata = event.assistantMetadata;
+        continue;
+      }
+      const payload = {
+        ...event.error,
+        requestId: options.requestId
+      };
+      yield { type: "error", sessionId: options.sessionId, error: payload };
+      throw new SessionExecutionError(payload);
+    }
+    return {
+      requestId: options.requestId,
+      text: assistantTextParts.join(""),
+      thinking: thinkingParts.join("") || undefined,
+      toolCalls,
+      stopReason,
+      usage: responseUsage,
+      assistantMetadata
+    };
+  }
+}
+
+// src/agent-core/session-status.ts
+function createSessionStatus(state) {
+  return {
+    sessionId: state.id,
+    model: { ...state.modelRef },
+    cwd: state.cwd,
+    usage: { ...state.usage },
+    compaction: cloneCompactionState(state.compaction),
+    messageCount: state.messages.length,
+    createdAt: state.createdAt,
+    updatedAt: state.updatedAt,
+    metadata: state.metadata ? structuredClone(state.metadata) : undefined
+  };
+}
+
+// src/agent-core/loop-runner.ts
+class LoopRunner {
+  messageFactory;
+  turnCollector;
+  toolExecutor;
+  terminationPolicy;
+  contextManager;
+  pluginHost;
+  notificationBus;
+  constructor(dependencies) {
+    this.messageFactory = dependencies.messageFactory;
+    this.turnCollector = dependencies.turnCollector;
+    this.toolExecutor = dependencies.toolExecutor;
+    this.terminationPolicy = dependencies.terminationPolicy;
+    this.contextManager = dependencies.contextManager;
+    this.pluginHost = dependencies.pluginHost;
+    this.notificationBus = dependencies.notificationBus;
+  }
+  async* run(state, input, options = {}) {
+    const startPayload = await this.pluginHost?.runMiddleware("run.start", {
+      sessionId: state.id,
+      input
+    }, this.createHookContext(state));
+    const initialInput = startPayload?.input ?? input;
+    await this.pluginHost?.runObservers("run.start", {
+      sessionId: state.id,
+      input: initialInput
+    }, this.createHookContext(state));
+    const userMessage = this.messageFactory.createUserMessage(initialInput);
+    state.messages.push(userMessage);
+    touchRuntimeSessionState(state);
+    await this.notificationBus.emit({
+      type: "run.start",
+      source: "runtime",
+      message: `Run started for session ${state.id}`,
+      metadata: {
+        sessionId: state.id
+      }
+    }, {
+      ...this.createHookContext(state)
+    });
+    let lastRequestId;
+    let lastIteration = 0;
+    let pendingContextSegments = [];
+    try {
+      for (let iteration = 0;iteration < state.maxIterations; iteration += 1) {
+        lastIteration = iteration;
+        const requestId = createId("req");
+        lastRequestId = requestId;
+        const turnStart = await this.pluginHost?.runMiddleware("turn.start", {
+          requestId,
+          iteration,
+          messages: [...state.messages]
+        }, this.createHookContext(state, { requestId, iteration }));
+        const contextItems = await this.contextManager.resolve({
+          sessionId: state.id,
+          input: initialInput,
+          messages: state.messages,
+          cwd: state.cwd
+        });
+        const resolvedContext = await this.pluginHost?.runMiddleware("context.resolve", {
+          contextItems,
+          input: initialInput,
+          messages: [...state.messages]
+        }, this.createHookContext(state, { requestId, iteration }));
+        const effectiveContext = resolvedContext?.contextItems ?? contextItems;
+        const pluginPromptSegments = await this.pluginHost?.collectPromptSegments({
+          sessionId: state.id,
+          input: initialInput,
+          messages: state.messages,
+          contextItems: effectiveContext,
+          cwd: state.cwd
+        }) ?? [];
+        const promptSegments = [
+          ...options.persistentPromptSegments ?? [],
+          ...pendingContextSegments,
+          ...this.contextManager.format(effectiveContext),
+          ...pluginPromptSegments
+        ];
+        pendingContextSegments = [];
+        const resolvedPrompt = await this.pluginHost?.runMiddleware("prompt.resolve", {
+          promptSegments,
+          contextItems: effectiveContext,
+          messages: [...state.messages]
+        }, this.createHookContext(state, { requestId, iteration }));
+        const effectivePromptSegments = resolvedPrompt?.promptSegments ?? promptSegments;
+        const toolDefinitions = state.tools?.definitions() ?? [];
+        const resolvedToolset = await this.pluginHost?.runMiddleware("toolset.resolve", {
+          tools: toolDefinitions
+        }, this.createHookContext(state, { requestId, iteration }));
+        const effectiveTools = resolvedToolset?.tools ?? toolDefinitions;
+        const requestMessages = await this.resolveRequestMessages({
+          state,
+          requestId,
+          iteration,
+          baseMessages: [...turnStart?.messages ?? state.messages],
+          runtimePromptSegments: effectivePromptSegments,
+          contextItems: effectiveContext,
+          tools: effectiveTools
+        });
+        const request = {
+          requestId,
+          model: state.modelRef,
+          messages: requestMessages,
+          tools: effectiveTools,
+          reasoning: state.reasoning,
+          signal: options.signal
+        };
+        const resolvedRequest = await this.pluginHost?.runMiddleware("model.request", {
+          request
+        }, this.createHookContext(state, { requestId, iteration }));
+        const effectiveRequest = resolvedRequest?.request ?? request;
+        const turn = yield* this.turnCollector.collect({
+          sessionId: state.id,
+          requestId,
+          events: state.model.stream(effectiveRequest),
+          onEvent: async (event) => {
+            if (event.type === "error") {
+              await this.notificationBus.emit({
+                type: "provider.error",
+                source: "provider",
+                level: "error",
+                message: event.error.message,
+                metadata: {
+                  requestId,
+                  code: event.error.code,
+                  status: event.error.status
+                }
+              }, {
+                ...this.createHookContext(state, { requestId, iteration })
+              });
+            }
+            await this.pluginHost?.runObservers("model.event", { event }, {
+              ...this.createHookContext(state, { requestId, iteration })
+            });
+          }
+        });
+        const assistantDraft = this.messageFactory.createAssistantMessage({
+          text: turn.text,
+          thinking: turn.thinking,
+          toolCalls: turn.toolCalls,
+          stopReason: turn.stopReason,
+          metadata: turn.assistantMetadata
+        });
+        const assistantPayload = await this.pluginHost?.runMiddleware("assistant.message", {
+          message: assistantDraft
+        }, this.createHookContext(state, { requestId, iteration }));
+        let assistantMessage = assistantPayload?.message ?? assistantDraft;
+        state.messages.push(assistantMessage);
+        state.usage = addUsage(state.usage, turn.usage);
+        touchRuntimeSessionState(state);
+        const baseDecision = this.terminationPolicy.afterAssistantTurn(turn.toolCalls);
+        const stopBasePayload = {
+          assistantMessage,
+          toolCalls: turn.toolCalls,
+          stopReason: turn.stopReason,
+          decision: baseDecision
+        };
+        const stopResult = await this.pluginHost?.runRunStop(stopBasePayload, {
+          ...this.createHookContext(state, { requestId, iteration })
+        });
+        const stopPayload = stopResult?.payload ?? stopBasePayload;
+        const stopControl = stopResult?.control;
+        await this.pluginHost?.runObservers("run.stop", {
+          ...stopPayload,
+          additionalContext: stopControl?.type === "finalize" ? stopControl.additionalContext ?? stopPayload.additionalContext : stopPayload.additionalContext,
+          finalMessage: stopControl?.type === "finalize" ? stopControl.finalMessage ?? stopPayload.finalMessage : stopPayload.finalMessage
+        }, this.createHookContext(state, { requestId, iteration }));
+        const stopDecision = stopControl?.type === "finalize" ? { type: "done" } : stopPayload.decision;
+        const additionalContext = stopControl?.type === "finalize" ? stopControl.additionalContext : stopPayload.additionalContext;
+        const finalMessage = stopControl?.type === "finalize" ? stopControl.finalMessage ?? stopPayload.finalMessage ?? stopPayload.assistantMessage : stopPayload.finalMessage ?? stopPayload.assistantMessage;
+        if (additionalContext && additionalContext.length > 0 && stopDecision.type === "continue")
+          pendingContextSegments = [...pendingContextSegments, ...additionalContext];
+        if (stopDecision.type === "done") {
+          assistantMessage = finalMessage;
+          state.messages[state.messages.length - 1] = assistantMessage;
+          touchRuntimeSessionState(state);
+          const endPayload = await this.pluginHost?.runMiddleware("run.end", {
+            message: assistantMessage,
+            usage: { ...state.usage }
+          }, this.createHookContext(state, { requestId, iteration }));
+          const completedMessage = endPayload?.message ?? assistantMessage;
+          const completedUsage = endPayload?.usage ?? { ...state.usage };
+          state.messages[state.messages.length - 1] = completedMessage;
+          state.usage = { ...completedUsage };
+          touchRuntimeSessionState(state);
+          await this.notificationBus.emit({
+            type: "run.end",
+            source: "runtime",
+            message: `Run completed for session ${state.id}`,
+            metadata: {
+              sessionId: state.id,
+              requestId
+            }
+          }, {
+            ...this.createHookContext(state, { requestId, iteration })
+          });
+          yield {
+            type: "done",
+            sessionId: state.id,
+            message: completedMessage,
+            usage: completedUsage
+          };
+          await this.pluginHost?.runObservers("run.end", {
+            message: completedMessage,
+            usage: completedUsage
+          }, this.createHookContext(state, { requestId, iteration }));
+          await options.onDone?.(completedMessage);
+          return completedMessage;
+        }
+        for (const toolCall of turn.toolCalls) {
+          yield { type: "tool_call", sessionId: state.id, toolCall };
+          const pluginEvents = [];
+          const result = await this.toolExecutor.execute(toolCall, {
+            signal: options.signal,
+            cwd: state.cwd,
+            requestId,
+            iteration,
+            status: createSessionStatus(state),
+            onEvent: async (event) => {
+              pluginEvents.push(event);
+            }
+          });
+          for (const event of pluginEvents)
+            yield event;
+          const toolMessage = this.messageFactory.createToolMessage(toolCall, result);
+          state.messages.push(toolMessage);
+          touchRuntimeSessionState(state);
+          yield { type: "tool_result", sessionId: state.id, toolCallId: toolCall.id, result };
+        }
+      }
+    } catch (error) {
+      if (error instanceof SessionExecutionError) {
+        await this.notificationBus.emit({
+          type: error.payload.code.startsWith("openai_") || error.payload.code.startsWith("anthropic_") || error.payload.code.startsWith("gemini_") ? "provider.error" : "runtime.error",
+          source: error.payload.code.includes("_http_") || error.payload.code.includes("_request_") ? "provider" : "runtime",
+          level: "error",
+          message: error.payload.message,
+          metadata: {
+            requestId: lastRequestId,
+            code: error.payload.code
+          }
+        }, {
+          ...this.createHookContext(state, { requestId: lastRequestId, iteration: lastIteration })
+        });
+        await this.pluginHost?.runObservers("session.error", { error: error.payload }, {
+          ...this.createHookContext(state, { requestId: lastRequestId })
+        });
+      }
+      throw error;
+    }
+    const payload = this.terminationPolicy.onMaxIterationsExceeded(state.maxIterations, lastRequestId);
+    yield { type: "error", sessionId: state.id, error: payload };
+    await this.notificationBus.emit({
+      type: "runtime.error",
+      source: "runtime",
+      level: "error",
+      message: payload.message,
+      metadata: {
+        requestId: lastRequestId,
+        code: payload.code
+      }
+    }, {
+      ...this.createHookContext(state, { requestId: lastRequestId, iteration: lastIteration })
+    });
+    await this.pluginHost?.runObservers("session.error", { error: payload }, {
+      ...this.createHookContext(state, { requestId: lastRequestId })
+    });
+    throw new SessionExecutionError(payload);
+  }
+  async resolveRequestMessages(input) {
+    const initialAttempt = await this.buildProjectedRequestMessages(input.state, input.baseMessages, input.runtimePromptSegments, input.tools);
+    if (!isCompactionRequired(input.state.compactionOptions, initialAttempt.budget))
+      return initialAttempt.messages;
+    const budget = initialAttempt.budget;
+    if (!budget)
+      return initialAttempt.messages;
+    await this.notificationBus.emit({
+      type: "context.compaction.required",
+      source: "runtime",
+      level: "warning",
+      message: `Context compaction required for session ${input.state.id}`,
+      metadata: {
+        requestId: input.requestId,
+        estimatedInputTokens: budget.estimatedInputTokens,
+        thresholdTokens: budget.thresholdTokens,
+        maxInputTokens: budget.maxInputTokens,
+        cursor: input.state.compaction.cursor
+      }
+    }, {
+      ...this.createHookContext(input.state, { requestId: input.requestId, iteration: input.iteration })
+    });
+    const beforeState = cloneCompactionState(input.state.compaction);
+    const compactPayload = await this.pluginHost?.runMiddleware("context.compact.before", {
+      sessionId: input.state.id,
+      messages: [...input.state.messages],
+      cursor: beforeState.cursor,
+      systemSegments: [...beforeState.systemSegments],
+      contextItems: input.contextItems,
+      estimatedInputTokens: budget.estimatedInputTokens,
+      thresholdTokens: budget.thresholdTokens,
+      maxInputTokens: budget.maxInputTokens,
+      trigger: "threshold"
+    }, {
+      ...this.createHookContext(input.state, { requestId: input.requestId, iteration: input.iteration })
+    });
+    await this.pluginHost?.runObservers("context.compact.before", compactPayload ?? {
+      sessionId: input.state.id,
+      messages: [...input.state.messages],
+      cursor: beforeState.cursor,
+      systemSegments: [...beforeState.systemSegments],
+      contextItems: input.contextItems,
+      estimatedInputTokens: budget.estimatedInputTokens,
+      thresholdTokens: budget.thresholdTokens,
+      maxInputTokens: budget.maxInputTokens,
+      trigger: "threshold"
+    }, {
+      ...this.createHookContext(input.state, { requestId: input.requestId, iteration: input.iteration })
+    });
+    input.state.compaction = normalizeCompactionState(input.state.compaction, input.state.messages);
+    const afterState = cloneCompactionState(input.state.compaction);
+    if (didCompactionStateChange(beforeState, afterState)) {
+      const latestCheckpoint = afterState.checkpoints.at(-1);
+      await this.notificationBus.emit({
+        type: "context.compacted",
+        source: "runtime",
+        level: "info",
+        message: `Context compacted for session ${input.state.id}`,
+        metadata: {
+          requestId: input.requestId,
+          cursor: afterState.cursor,
+          checkpointId: latestCheckpoint?.id,
+          reason: latestCheckpoint?.reason
+        }
+      }, {
+        ...this.createHookContext(input.state, { requestId: input.requestId, iteration: input.iteration })
+      });
+    }
+    const compactedAttempt = await this.buildProjectedRequestMessages(input.state, input.baseMessages, input.runtimePromptSegments, input.tools);
+    if (!isCompactionRequired(input.state.compactionOptions, compactedAttempt.budget))
+      return compactedAttempt.messages;
+    throw new SessionExecutionError({
+      code: "context_compaction_required",
+      message: `Context compaction required before continuing the run (estimated ${budget.estimatedInputTokens} tokens, threshold ${budget.thresholdTokens})`,
+      requestId: input.requestId
+    });
+  }
+  async buildProjectedRequestMessages(state, baseMessages, runtimePromptSegments, tools) {
+    const projectedMessages = projectMessagesForRequest(baseMessages, state.compaction);
+    const promptSegments = [
+      ...buildCompactionPromptSegments(state.compaction),
+      ...runtimePromptSegments
+    ];
+    const requestMessages = [...projectedMessages];
+    if (promptSegments.length > 0)
+      requestMessages.unshift(this.messageFactory.createSystemMessage(promptSegments.join(`
+
+`)));
+    const budget = state.compactionOptions && state.compactionOptions.enabled !== false ? await estimateCompactionBudget(state.compactionOptions, {
+      model: state.modelRef,
+      messages: requestMessages,
+      tools
+    }) : undefined;
+    return {
+      messages: requestMessages,
+      budget
+    };
+  }
+  createHookContext(state, input = {}) {
+    return {
+      sessionId: state.id,
+      requestId: input.requestId,
+      iteration: input.iteration,
+      cwd: state.cwd,
+      metadata: state.metadata,
+      status: createSessionStatus(state)
+    };
+  }
+}
+
+// src/agent-core/termination-policy.ts
+class DefaultTerminationPolicy {
+  afterAssistantTurn(toolCalls) {
+    return toolCalls.length === 0 ? { type: "done" } : { type: "continue" };
+  }
+  onMaxIterationsExceeded(maxIterations, requestId) {
+    return {
+      code: "max_iterations_exceeded",
+      message: `Session exceeded maxIterations (${maxIterations})`,
+      requestId
+    };
+  }
+}
+
+// src/agent-core/tool-executor.ts
+class DefaultToolExecutor {
+  sessionId;
+  tools;
+  metadata;
+  services;
+  pluginHost;
+  approvalManager;
+  notificationBus;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.tools = options.tools;
+    this.metadata = options.metadata;
+    this.services = options.services;
+    this.pluginHost = options.pluginHost;
+    this.approvalManager = options.approvalManager;
+    this.notificationBus = options.notificationBus;
+  }
+  async execute(toolCall, options = {}) {
+    const hookContext = {
+      sessionId: this.sessionId,
+      requestId: options.requestId,
+      iteration: options.iteration,
+      cwd: options.cwd,
+      status: options.status,
+      services: this.services,
+      metadata: this.metadata
+    };
+    const before = await this.pluginHost?.runToolBeforeExecute({
+      toolCall
+    }, hookContext);
+    let currentToolCall = before?.payload.toolCall ?? toolCall;
+    let result;
+    if (before?.control) {
+      if (before.control.type === "provideResult") {
+        result = normalizeToolResult(before.control.result);
+      } else if (before.control.type === "deny") {
+        result = normalizeToolResult(before.control.result ?? {
+          ...textToolResult(before.control.reason ?? `Tool denied: ${currentToolCall.function.name}`),
+          isError: true
+        });
+        await this.notificationBus.emit({
+          type: "tool.denied",
+          source: "permission",
+          level: "warning",
+          message: before.control.reason ?? `Tool denied: ${currentToolCall.function.name}`,
+          metadata: {
+            toolName: currentToolCall.function.name
+          }
+        }, hookContext);
+      } else if (before.control.type === "ask") {
+        currentToolCall = before.control.toolCall ?? currentToolCall;
+        const approvalRequest = {
+          id: undefined,
+          kind: "tool_execution",
+          toolCall: currentToolCall,
+          message: before.control.request?.message ?? `Approval required to execute tool: ${currentToolCall.function.name}`,
+          metadata: before.control.request?.metadata
+        };
+        const decision = await this.approvalManager.requestApproval(approvalRequest, hookContext);
+        if (decision.type === "denied") {
+          result = normalizeToolResult({
+            ...textToolResult(decision.reason ?? `Tool approval denied: ${currentToolCall.function.name}`),
+            isError: true
+          });
+        }
+      }
+    }
+    if (!result) {
+      const tool = this.tools?.get(currentToolCall.function.name);
+      if (!tool) {
+        result = normalizeToolResult({ ...textToolResult(`Tool not found: ${currentToolCall.function.name}`), isError: true });
+      } else {
+        try {
+          result = normalizeToolResult(await tool.execute(currentToolCall.function.arguments, {
+            sessionId: this.sessionId,
+            cwd: options.cwd,
+            signal: options.signal,
+            metadata: this.metadata,
+            services: this.services,
+            emitEvent: async (event) => {
+              const pluginId = event.pluginId;
+              if (!pluginId)
+                throw new Error(`Tool ${currentToolCall.function.name} emitted a plugin event without pluginId`);
+              await options.onEvent?.({
+                type: "plugin_event",
+                sessionId: this.sessionId,
+                pluginId,
+                event: event.event,
+                data: event.data ? structuredClone(event.data) : undefined
+              });
+            }
+          }));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          result = normalizeToolResult({
+            ...textToolResult(message),
+            isError: true
+          });
+        }
+      }
+    }
+    const after = await this.pluginHost?.runMiddleware("tool.afterExecute", {
+      toolCall: currentToolCall,
+      result
+    }, hookContext);
+    const finalResult = normalizeToolResult(after?.result ?? result);
+    await this.notificationBus.emit({
+      type: finalResult.isError ? "tool.failed" : "tool.completed",
+      source: "tool",
+      level: finalResult.isError ? "error" : "info",
+      message: finalResult.isError ? `Tool failed: ${currentToolCall.function.name}` : `Tool completed: ${currentToolCall.function.name}`,
+      metadata: {
+        toolName: currentToolCall.function.name,
+        isError: finalResult.isError === true
+      }
+    }, hookContext);
+    return finalResult;
+  }
+}
+
+// src/agent-core/session.ts
+var DEFAULT_MESSAGE_QUEUE_CONFIG = {
+  autoProcessQueue: true
+};
+
+class Session {
+  id;
+  createdAt;
+  stateStore;
+  state;
+  pluginHost;
+  contextManager;
+  services;
+  approvalManager;
+  notificationBus;
+  compactionService;
+  pluginStateService;
+  pluginControllers;
+  bufferedEvents = [];
+  stateChangeWaiters = [];
+  activeRunCount = 0;
+  processingPromise = null;
+  receiveActive = false;
+  activeReceiveSignal;
+  haltProcessingUntilReceive = false;
+  saveChain = Promise.resolve();
+  constructor(options) {
+    const now = Date.now();
+    this.id = options.id ?? createId("session");
+    this.createdAt = options.createdAt ?? now;
+    this.stateStore = options.stateStore;
+    this.pluginHost = options.pluginHost;
+    this.contextManager = options.contextManager;
+    this.services = options.services;
+    this.approvalManager = options.approvalManager;
+    this.notificationBus = options.notificationBus;
+    this.compactionService = options.compactionService;
+    this.pluginStateService = options.pluginStateService;
+    this.state = {
+      id: this.id,
+      model: options.model,
+      modelRef: options.modelRef ?? options.model.model,
+      tools: options.tools,
+      maxIterations: options.maxIterations ?? 8,
+      cwd: options.cwd,
+      metadata: options.metadata,
+      reasoning: options.reasoning,
+      messages: [...options.messages ?? []],
+      usage: options.usage ? { ...options.usage } : createEmptyUsage(),
+      compaction: cloneCompactionState(options.compaction ?? createEmptyCompactionState()),
+      pluginState: clonePluginStateMap(options.pluginState),
+      messageQueue: cloneMessageQueueSnapshot(options.messageQueue ?? {
+        items: [],
+        config: createMessageQueueConfig(options.messageQueueConfig)
+      }),
+      compactionOptions: options.compactionOptions,
+      createdAt: this.createdAt,
+      updatedAt: options.updatedAt ?? now
+    };
+    if (options.messageQueueConfig)
+      this.state.messageQueue.config = createMessageQueueConfig(options.messageQueueConfig, this.state.messageQueue.config);
+    this.compactionService.registerSession(this.state);
+    this.pluginStateService.registerSession(this.state);
+    this.pluginControllers = this.pluginHost?.createSessionControllers({
+      sessionId: this.id,
+      metadata: this.state.metadata,
+      getStatus: () => this.getStatus(),
+      save: () => this.save(),
+      isRunning: () => this.activeRunCount > 0
+    }) ?? new Map;
+  }
+  get messages() {
+    return [...this.state.messages];
+  }
+  get usage() {
+    return { ...this.state.usage };
+  }
+  getStatus() {
+    return createSessionStatus(this.state);
+  }
+  getCompactionState() {
+    return cloneCompactionState(this.state.compaction);
+  }
+  getPluginState(pluginId) {
+    return clonePluginSessionStateEntry(this.state.pluginState[pluginId]);
+  }
+  listPluginStates() {
+    return clonePluginStateMap(this.state.pluginState);
+  }
+  getPlugin(pluginId) {
+    return this.pluginControllers.get(pluginId) ?? null;
+  }
+  get updatedAt() {
+    return this.state.updatedAt;
+  }
+  getCwd() {
+    return this.state.cwd;
+  }
+  setCwd(cwd) {
+    this.state.cwd = cwd;
+    touchRuntimeSessionState(this.state);
+  }
+  send(input, options = {}) {
+    return this.enqueueItem("user", input, options);
+  }
+  sendBatch(items) {
+    const maxQueueSize = this.state.messageQueue.config.maxQueueSize;
+    if (maxQueueSize !== undefined && this.state.messageQueue.items.length + items.length > maxQueueSize)
+      throw new SessionExecutionError(createQueueError("DIM_QUEUE_FULL", `Session queue is full (max ${maxQueueSize})`));
+    const prepared = items.map(({ input, options }) => prepareQueueItem("user", input, options));
+    for (const item of prepared)
+      this.state.messageQueue.items.push(item);
+    if (prepared.length > 0)
+      this.onQueueMutated();
+    return prepared.map((item) => item.id);
+  }
+  steer(input, options = {}) {
+    return this.enqueueItem("steer", input, options);
+  }
+  cancelQueuedItem(itemId) {
+    const index = this.state.messageQueue.items.findIndex((item) => item.id === itemId);
+    if (index < 0)
+      return false;
+    this.state.messageQueue.items.splice(index, 1);
+    this.onQueueMutated();
+    return true;
+  }
+  getQueueStatus() {
+    const items = [...this.state.messageQueue.items].sort(compareQueueItems).map((item) => ({
+      id: item.id,
+      kind: item.kind,
+      priority: item.priority,
+      enqueuedAt: item.enqueuedAt,
+      preview: createQueuePreview(item.input)
+    }));
+    return {
+      length: items.length,
+      items,
+      isProcessing: this.processingPromise !== null,
+      config: cloneMessageQueueConfig(this.state.messageQueue.config)
+    };
+  }
+  clearQueue(filter = {}) {
+    const before = this.state.messageQueue.items.length;
+    if (!filter.kind) {
+      this.state.messageQueue.items = [];
+    } else {
+      this.state.messageQueue.items = this.state.messageQueue.items.filter((item) => item.kind !== filter.kind);
+    }
+    const cleared = before - this.state.messageQueue.items.length;
+    if (cleared > 0)
+      this.onQueueMutated();
+    return cleared;
+  }
+  async* receive(options = {}) {
+    if (this.receiveActive)
+      throw new SessionExecutionError(createQueueError("DIM_QUEUE_BUSY", "Only one receive() call can be active for a session"));
+    this.receiveActive = true;
+    this.activeReceiveSignal = options.signal;
+    this.haltProcessingUntilReceive = false;
+    let deliveredEvent = null;
+    try {
+      while (true) {
+        if (deliveredEvent) {
+          deliveredEvent.ack();
+          deliveredEvent = null;
+        }
+        this.ensureQueueProcessing("receive");
+        const nextBufferedEvent = this.bufferedEvents.shift();
+        if (nextBufferedEvent) {
+          deliveredEvent = nextBufferedEvent;
+          yield nextBufferedEvent.event;
+          continue;
+        }
+        if (!this.processingPromise && !this.hasRunnableItems())
+          return;
+        await this.waitForStateChange(options.signal);
+      }
+    } finally {
+      if (deliveredEvent)
+        deliveredEvent.ack();
+      this.receiveActive = false;
+      if (this.activeReceiveSignal === options.signal)
+        this.activeReceiveSignal = undefined;
+      this.notifyStateChange();
+    }
+  }
+  async compact(update) {
+    const beforeState = this.getCompactionState();
+    const estimatedInputTokens = await this.readEstimatedInputTokens();
+    const thresholdTokens = this.state.compactionOptions?.triggerTokens ?? (this.state.compactionOptions ? Math.max(1, Math.floor(this.state.compactionOptions.maxInputTokens * (this.state.compactionOptions.triggerRatio ?? 0.8))) : 0);
+    const maxInputTokens = this.state.compactionOptions?.maxInputTokens ?? 0;
+    const payload = {
+      sessionId: this.id,
+      messages: this.messages,
+      cursor: beforeState.cursor,
+      systemSegments: [...beforeState.systemSegments],
+      contextItems: undefined,
+      estimatedInputTokens,
+      thresholdTokens,
+      maxInputTokens,
+      trigger: "manual"
+    };
+    if (this.pluginHost) {
+      const compactPayload = await this.pluginHost.runMiddleware("context.compact.before", payload, {
+        ...this.createHookContext(),
+        services: this.services
+      });
+      await this.pluginHost.runObservers("context.compact.before", compactPayload, {
+        ...this.createHookContext(),
+        services: this.services
+      });
+    }
+    await this.compactionService.apply({
+      sessionId: this.id,
+      ...update,
+      reason: update.reason ?? "manual"
+    });
+    const afterState = this.getCompactionState();
+    const latestCheckpoint = afterState.checkpoints.at(-1);
+    await this.notificationBus.emit({
+      type: "context.compacted",
+      source: "runtime",
+      level: "info",
+      message: `Context compacted for session ${this.id}`,
+      metadata: {
+        cursor: afterState.cursor,
+        checkpointId: latestCheckpoint?.id,
+        reason: latestCheckpoint?.reason
+      }
+    }, {
+      ...this.createHookContext()
+    });
+  }
+  async save() {
+    return this.enqueueSave();
+  }
+  async writeSnapshot() {
+    if (!this.stateStore)
+      return;
+    let snapshot = this.toSnapshot();
+    if (this.pluginHost) {
+      snapshot = await this.pluginHost.runMiddleware("snapshot.encode", { snapshot }, {
+        ...this.createHookContext(),
+        services: this.services
+      }).then((payload) => payload.snapshot);
+    }
+    await this.stateStore.save(snapshot);
+    await this.notificationBus.emit({
+      type: "snapshot.saved",
+      source: "persistence",
+      level: "info",
+      message: `Saved snapshot for session ${this.id}`,
+      metadata: {
+        sessionId: this.id,
+        schemaVersion: snapshot.schemaVersion
+      }
+    }, {
+      ...this.createHookContext()
+    });
+  }
+  toSnapshot() {
+    return sessionSnapshotCodec.encode({
+      sessionId: this.id,
+      model: this.state.modelRef,
+      cwd: this.state.cwd,
+      messages: this.messages,
+      usage: this.usage,
+      compaction: this.getCompactionState(),
+      pluginState: this.listPluginStates(),
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      metadata: this.state.metadata ? { ...this.state.metadata } : undefined,
+      messageQueue: cloneMessageQueueSnapshot(this.state.messageQueue)
+    });
+  }
+  enqueueItem(kind, input, options) {
+    const maxQueueSize = this.state.messageQueue.config.maxQueueSize;
+    if (maxQueueSize !== undefined && this.state.messageQueue.items.length >= maxQueueSize)
+      throw new SessionExecutionError(createQueueError("DIM_QUEUE_FULL", `Session queue is full (max ${maxQueueSize})`));
+    const item = prepareQueueItem(kind, input, options);
+    this.state.messageQueue.items.push(item);
+    this.onQueueMutated();
+    return item.id;
+  }
+  onQueueMutated() {
+    touchRuntimeSessionState(this.state);
+    this.notifyStateChange();
+    this.scheduleSave();
+    this.ensureQueueProcessing("auto");
+  }
+  hasRunnableItems() {
+    return this.state.messageQueue.items.some((item) => item.kind === "user");
+  }
+  ensureQueueProcessing(source) {
+    if (this.processingPromise)
+      return;
+    if (!this.hasRunnableItems())
+      return;
+    if (this.haltProcessingUntilReceive && source !== "receive")
+      return;
+    const signal = source === "receive" ? this.activeReceiveSignal : undefined;
+    this.processingPromise = this.processQueue(signal).finally(() => {
+      this.processingPromise = null;
+      this.notifyStateChange();
+      if (!this.haltProcessingUntilReceive && this.state.messageQueue.config.autoProcessQueue)
+        this.ensureQueueProcessing("auto");
+    });
+    this.notifyStateChange();
+  }
+  async processQueue(signal) {
+    while (true) {
+      const nextItem = this.dequeueNextRunnableItem();
+      if (!nextItem)
+        return;
+      const completed = await this.processQueuedItem(nextItem, signal);
+      await this.persistStateQuietly();
+      if (!completed) {
+        this.haltProcessingUntilReceive = true;
+        return;
+      }
+    }
+  }
+  dequeueNextRunnableItem() {
+    const rankedItems = [...this.state.messageQueue.items].sort(compareQueueItems);
+    const userIndex = rankedItems.findIndex((item) => item.kind === "user");
+    if (userIndex < 0)
+      return null;
+    const userItem = rankedItems[userIndex];
+    const steerItems = rankedItems.slice(0, userIndex).filter((item) => item.kind === "steer");
+    const consumedIds = new Set([userItem.id, ...steerItems.map((item) => item.id)]);
+    this.state.messageQueue.items = this.state.messageQueue.items.filter((item) => !consumedIds.has(item.id));
+    touchRuntimeSessionState(this.state);
+    this.notifyStateChange();
+    return {
+      item: userItem,
+      steerSegments: steerItems.map((item) => contentToText(normalizeContent(item.input)).trim()).filter((segment) => segment.length > 0)
+    };
+  }
+  async processQueuedItem(input, signal) {
+    const runner = this.createLoopRunner();
+    let emittedError = false;
+    this.activeRunCount += 1;
+    try {
+      const iterator = runner.run(this.state, input.item.input, {
+        signal,
+        persistentPromptSegments: input.steerSegments
+      });
+      while (true) {
+        const next = await iterator.next();
+        if (next.done)
+          return true;
+        const queuedEvent = this.attachQueueContext(next.value, input.item);
+        if (queuedEvent.type === "error")
+          emittedError = true;
+        await this.pushBufferedEvent(queuedEvent);
+      }
+    } catch (error) {
+      if (!emittedError)
+        await this.pushBufferedEvent(this.createErrorEvent(input.item, error));
+      return false;
+    } finally {
+      this.activeRunCount = Math.max(0, this.activeRunCount - 1);
+      this.notifyStateChange();
+    }
+  }
+  attachQueueContext(event, item) {
+    return {
+      ...event,
+      itemId: item.id,
+      itemKind: item.kind,
+      priority: item.priority
+    };
+  }
+  createErrorEvent(item, error) {
+    const payload = error instanceof SessionExecutionError ? error.payload : {
+      code: "runtime_error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+    return {
+      type: "error",
+      sessionId: this.id,
+      error: payload,
+      itemId: item.id,
+      itemKind: item.kind,
+      priority: item.priority
+    };
+  }
+  async pushBufferedEvent(event) {
+    let resolved = false;
+    const ack = () => {
+      if (resolved)
+        return;
+      resolved = true;
+      this.notifyStateChange();
+    };
+    this.bufferedEvents.push({ event, ack });
+    this.notifyStateChange();
+    while (!resolved)
+      await this.waitForStateChange();
+  }
+  scheduleSave() {
+    if (!this.stateStore)
+      return;
+    this.enqueueSave().catch(() => {
+      return;
+    });
+  }
+  async persistStateQuietly() {
+    try {
+      await this.enqueueSave();
+    } catch {}
+  }
+  enqueueSave() {
+    if (!this.stateStore)
+      return Promise.resolve();
+    this.saveChain = this.saveChain.catch(() => {
+      return;
+    }).then(() => this.writeSnapshot());
+    return this.saveChain;
+  }
+  waitForStateChange(signal) {
+    if (signal?.aborted)
+      return Promise.reject(new SessionExecutionError(createQueueError("session_receive_aborted", "Session receive aborted")));
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        cleanup();
+        reject(new SessionExecutionError(createQueueError("session_receive_aborted", "Session receive aborted")));
+      };
+      const resume = () => {
+        cleanup();
+        resolve();
+      };
+      const cleanup = () => {
+        const index = this.stateChangeWaiters.indexOf(resume);
+        if (index >= 0)
+          this.stateChangeWaiters.splice(index, 1);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      this.stateChangeWaiters.push(resume);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  notifyStateChange() {
+    while (this.stateChangeWaiters.length > 0)
+      this.stateChangeWaiters.shift()?.();
+  }
+  createLoopRunner() {
+    return new LoopRunner({
+      messageFactory: new DefaultMessageFactory,
+      turnCollector: new DefaultModelTurnCollector,
+      toolExecutor: new DefaultToolExecutor({
+        sessionId: this.id,
+        tools: this.state.tools,
+        metadata: this.state.metadata,
+        services: this.services,
+        pluginHost: this.pluginHost,
+        approvalManager: this.approvalManager,
+        notificationBus: this.notificationBus
+      }),
+      terminationPolicy: new DefaultTerminationPolicy,
+      contextManager: this.contextManager,
+      pluginHost: this.pluginHost,
+      notificationBus: this.notificationBus
+    });
+  }
+  async readEstimatedInputTokens() {
+    if (!this.state.compactionOptions || this.state.compactionOptions.enabled === false)
+      return 0;
+    const projectedMessages = projectMessagesForRequest(this.state.messages, this.state.compaction);
+    const promptSegments = buildCompactionPromptSegments(this.state.compaction);
+    const requestMessages = [...projectedMessages];
+    if (promptSegments.length > 0)
+      requestMessages.unshift(new DefaultMessageFactory().createSystemMessage(promptSegments.join(`
+
+`)));
+    const budget = await estimateCompactionBudget(this.state.compactionOptions, {
+      model: this.state.modelRef,
+      messages: requestMessages,
+      tools: this.state.tools?.definitions() ?? []
+    });
+    return budget.estimatedInputTokens;
+  }
+  createHookContext(input = {}) {
+    return {
+      sessionId: this.id,
+      requestId: input.requestId,
+      iteration: input.iteration,
+      cwd: this.state.cwd,
+      metadata: this.state.metadata,
+      status: this.getStatus()
+    };
+  }
+}
+function createMessageQueueConfig(overrides, base = DEFAULT_MESSAGE_QUEUE_CONFIG) {
+  return {
+    autoProcessQueue: overrides?.autoProcessQueue ?? base.autoProcessQueue,
+    maxQueueSize: overrides?.maxQueueSize ?? base.maxQueueSize
+  };
+}
+function cloneMessageQueueConfig(config) {
+  return {
+    autoProcessQueue: config.autoProcessQueue,
+    maxQueueSize: config.maxQueueSize
+  };
+}
+function clonePendingMessage(item) {
+  return {
+    id: item.id,
+    input: structuredClone(item.input),
+    kind: item.kind,
+    priority: item.priority,
+    enqueuedAt: item.enqueuedAt
+  };
+}
+function cloneMessageQueueSnapshot(snapshot) {
+  return {
+    items: snapshot.items.map(clonePendingMessage),
+    config: cloneMessageQueueConfig(snapshot.config)
+  };
+}
+function prepareQueueItem(kind, input, options = {}) {
+  const normalizedInput = normalizeContent(input);
+  if (kind === "steer" && contentToText(normalizedInput).trim().length === 0)
+    throw new TypeError("Steer content must contain text");
+  return {
+    id: createId("item"),
+    input: structuredClone(input),
+    kind,
+    priority: options.priority ?? 0,
+    enqueuedAt: Date.now()
+  };
+}
+function compareQueueItems(left, right) {
+  if (left.priority !== right.priority)
+    return right.priority - left.priority;
+  if (left.enqueuedAt !== right.enqueuedAt)
+    return left.enqueuedAt - right.enqueuedAt;
+  return left.id.localeCompare(right.id);
+}
+function createQueuePreview(input) {
+  const text = contentToText(normalizeContent(input)).trim();
+  if (text.length === 0)
+    return "[non-text content]";
+  if (text.length <= 80)
+    return text;
+  return `${text.slice(0, 77)}...`;
+}
+function createQueueError(code, message) {
+  return { code, message };
+}
+
+// src/agent-core/agent.ts
+class Agent {
+  id;
+  pluginHost;
+  services;
+  tools;
+  permissions;
+  options;
+  messageFactory = new DefaultMessageFactory;
+  contextManager;
+  tracker;
+  permissionGateway;
+  approvalManager;
+  notificationBus;
+  compactionService;
+  pluginStateService;
+  constructor(options) {
+    this.id = createId("agent");
+    this.options = options;
+    this.permissions = options.permissions;
+    validateCompactionOwner(options);
+    this.tracker = new ActivityTracker;
+    this.compactionService = new DefaultCompactionService;
+    this.pluginStateService = new DefaultPluginStateService;
+    this.services = createServices(options, this.tracker, this.compactionService, this.pluginStateService);
+    this.permissionGateway = new PermissionGateway({
+      permissions: options.permissions,
+      compactionOwnerPluginId: options.compaction?.ownerPluginId
+    });
+    this.pluginHost = new PluginHost({
+      agentId: this.id,
+      cwd: options.cwd,
+      plugins: options.plugins,
+      services: this.services,
+      permissionGateway: this.permissionGateway,
+      tracker: this.tracker
+    });
+    this.notificationBus = new DefaultNotificationBus({
+      pluginHost: this.pluginHost,
+      services: this.services
+    });
+    this.approvalManager = new DefaultApprovalManager({
+      handler: options.approvalHandler,
+      notifications: this.notificationBus
+    });
+    this.contextManager = options.contextManager ?? new AutoContextManager({
+      services: this.services,
+      pluginHost: this.pluginHost
+    });
+    this.tools = createToolRegistry({
+      includeBuiltinTools: options.includeBuiltinTools !== false,
+      tools: options.tools,
+      pluginTools: this.pluginHost.pluginTools()
+    });
+  }
+  async createSession(options = {}) {
+    const messages = options.messages ? [...options.messages] : [];
+    if (options.systemPrompt)
+      messages.unshift(this.messageFactory.createSystemMessage(options.systemPrompt));
+    return new Session({
+      id: options.sessionId ?? createId("session"),
+      model: this.options.model,
+      modelRef: this.options.model.model,
+      tools: this.tools,
+      stateStore: this.options.stateStore,
+      maxIterations: this.options.maxIterations,
+      cwd: options.cwd ?? this.options.cwd,
+      metadata: options.metadata ?? this.options.metadata,
+      reasoning: this.options.reasoning,
+      compactionOptions: this.options.compaction,
+      messageQueueConfig: options.messageQueueConfig,
+      messages,
+      pluginHost: this.pluginHost,
+      contextManager: this.contextManager,
+      services: this.services,
+      approvalManager: this.approvalManager,
+      notificationBus: this.notificationBus,
+      compactionService: this.compactionService,
+      pluginStateService: this.pluginStateService
+    });
+  }
+  async restoreSession(sessionId) {
+    if (!this.options.stateStore)
+      return null;
+    const snapshot = await this.options.stateStore.load(sessionId);
+    if (!snapshot)
+      return null;
+    return this.sessionFromSnapshot(snapshot);
+  }
+  sessionFromSnapshot(snapshot) {
+    return new Session({
+      id: snapshot.sessionId,
+      model: this.options.model,
+      modelRef: snapshot.model ?? this.options.model.model,
+      tools: this.tools,
+      stateStore: this.options.stateStore,
+      maxIterations: this.options.maxIterations,
+      cwd: snapshot.cwd ?? this.options.cwd,
+      metadata: snapshot.metadata ?? this.options.metadata,
+      reasoning: this.options.reasoning,
+      messages: snapshot.messages,
+      usage: snapshot.usage,
+      compaction: snapshot.compaction,
+      pluginState: snapshot.pluginState,
+      messageQueue: snapshot.messageQueue,
+      compactionOptions: this.options.compaction,
+      createdAt: snapshot.createdAt,
+      updatedAt: snapshot.updatedAt,
+      pluginHost: this.pluginHost,
+      contextManager: this.contextManager,
+      services: this.services,
+      approvalManager: this.approvalManager,
+      notificationBus: this.notificationBus,
+      compactionService: this.compactionService,
+      pluginStateService: this.pluginStateService
+    });
+  }
+}
+function createAgent(options) {
+  return new Agent(options);
+}
+function createServices(options, tracker, compaction, pluginState) {
+  const exec = new NodeExecGateway({ cwd: options.cwd, tracker });
+  return {
+    fileSystem: new NodeFileSystemGateway({ cwd: options.cwd, tracker }),
+    exec,
+    git: new DefaultGitGateway({ exec, cwd: options.cwd }),
+    network: new DefaultNetworkGateway,
+    model: new DefaultModelGateway(options.model),
+    compaction,
+    pluginState
+  };
+}
+function validateCompactionOwner(options) {
+  const ownerPluginId = options.compaction?.ownerPluginId;
+  if (!ownerPluginId)
+    return;
+  const loadedPluginIds = new Set((options.plugins ?? []).map((plugin) => plugin.manifest.id));
+  if (!loadedPluginIds.has(ownerPluginId))
+    throw new Error(`Compaction owner plugin "${ownerPluginId}" is not loaded`);
+}
+function createToolRegistry(input) {
+  const registry = input.tools instanceof ToolRegistry ? cloneRegistry(input.tools) : new ToolRegistry;
+  if (input.includeBuiltinTools) {
+    safeRegister(registry, new ReadTool);
+    safeRegister(registry, new WriteTool);
+    safeRegister(registry, new EditTool);
+    safeRegister(registry, new ExecTool);
+  }
+  for (const tool of Array.isArray(input.tools) ? input.tools : [])
+    safeRegister(registry, tool);
+  for (const tool of input.pluginTools)
+    safeRegister(registry, tool);
+  return registry;
+}
+function cloneRegistry(source) {
+  const registry = new ToolRegistry;
+  for (const tool of source.list())
+    registry.register(tool);
+  return registry;
+}
+function safeRegister(registry, tool) {
+  if (!registry.get(tool.definition.name))
+    registry.register(tool);
+}
+// src/persistence/file-state-store.ts
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+class FileStateStore {
+  directory;
+  constructor(options) {
+    this.directory = path3.resolve(options.directory);
+  }
+  async save(snapshot) {
+    const validated = sessionSnapshotCodec.decode(snapshot);
+    await mkdir2(this.directory, { recursive: true });
+    await writeFile2(this.filePath(validated.sessionId), JSON.stringify(validated, null, 2), "utf8");
+  }
+  async load(sessionId) {
+    try {
+      const raw = await readFile2(this.filePath(sessionId), "utf8");
+      return sessionSnapshotCodec.decode(JSON.parse(raw));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+  }
+  async delete(sessionId) {
+    await rm(this.filePath(sessionId), { force: true });
+  }
+  async list() {
+    await mkdir2(this.directory, { recursive: true });
+    const entries = (await readdir2(this.directory)).sort();
+    const snapshots = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(".json"))
+        continue;
+      const raw = await readFile2(path3.join(this.directory, entry), "utf8");
+      snapshots.push(sessionSnapshotCodec.decode(JSON.parse(raw)));
+    }
+    return snapshots;
+  }
+  filePath(sessionId) {
+    return path3.join(this.directory, `${encodeURIComponent(sessionId)}.json`);
+  }
+}
+// src/persistence/in-memory-state-store.ts
+class InMemoryStateStore {
+  snapshots = new Map;
+  async save(snapshot) {
+    const validated = sessionSnapshotCodec.decode(snapshot);
+    this.snapshots.set(validated.sessionId, validated);
+  }
+  async load(sessionId) {
+    const snapshot = this.snapshots.get(sessionId);
+    return snapshot ? sessionSnapshotCodec.decode(snapshot) : null;
+  }
+  async delete(sessionId) {
+    this.snapshots.delete(sessionId);
+  }
+  async list() {
+    return [...this.snapshots.values()].map((snapshot) => sessionSnapshotCodec.decode(snapshot));
+  }
+}
+// src/agent-core/create-model.ts
+function createModel(adapter) {
+  return {
+    adapter,
+    model: adapter.defaultModel,
+    stream(request) {
+      return adapter.stream({
+        ...request,
+        model: request.model ?? adapter.defaultModel
+      });
+    }
+  };
+}
+export {
+  startToolCall,
+  normalizeToolSchema,
+  normalizeToolResult,
+  normalizePermissions,
+  normalizeContent,
+  fullPermissions,
+  finalizeToolCall,
+  createZenMuxAdapter,
+  createXaiResponsesAdapter,
+  createXaiAdapter,
+  createOpenAIResponsesAdapter,
+  createOpenAIAdapter,
+  createMoonshotAIAdapter,
+  createModel,
+  createGeminiAdapter,
+  createDeepSeekAdapter,
+  createAnthropicAdapter,
+  createAihubmixResponsesAdapter,
+  createAihubmixAdapter,
+  createAgent,
+  appendToolCallArgsDelta,
+  WriteTool,
+  ToolRegistry,
+  SessionExecutionError,
+  Session,
+  ReadTool,
+  PermissionGateway,
+  PermissionDeniedError,
+  NodeFileSystemGateway,
+  NodeExecGateway,
+  InMemoryStateStore,
+  FileStateStore,
+  ExecTool,
+  EditTool,
+  DefaultNetworkGateway,
+  DefaultModelGateway,
+  DefaultGitGateway,
+  DefaultCompactionService,
+  BaseTool,
+  AutoContextManager,
+  Agent,
+  ActivityTracker
+};