@sixb/core 0.1.7 → 0.1.9

package/dist/chunk-n2arzn6e.js

@@ -1,1745 +0,0 @@
-// @bun
-import {
-  SIXB_API_ROUTES,
-  matchesPathPattern,
-  normalizeRoutePath
-} from "./chunk-z2sery1b.js";
-import {
-  ModelProviderError,
-  ModelStreamError,
-  StructuredOutputError,
-  estimateModelCall,
-  rateModelCall
-} from "./chunk-p2vqaxkc.js";
-import {
-  AgentDefinitionError,
-  AgentMessageAdapterError,
-  AgentToolResultValidationError,
-  normalizeAgentContextEntries
-} from "./chunk-atmkaf60.js";
-import {
-  normalizeSchemaValue,
-  validateSchemaValue
-} from "./chunk-d63tybny.js";
-import {
-  OntologyValidationError
-} from "./chunk-dktq02ne.js";
-import {
-  isFileRef
-} from "./chunk-08m3b6w8.js";
-import {
-  assertJsonObject,
-  assertJsonValue,
-  cloneJsonValue,
-  getInvalidJsonValueReason,
-  isJsonValue,
-  isPlainRecord,
-  stableJsonStringify
-} from "./chunk-n6jxh8sw.js";
-
-// src/agents/context-model.ts
-function serializeAgentContextForModel(parts) {
-  if (parts.length === 0)
-    return;
-  const lines = ["<sixb_user_context>"];
-  for (const part of parts) {
-    if (part.context.kind === "object") {
-      lines.push("  <object_context>", `    <object_type_id>${escapeXml(part.context.ref.objectTypeId)}</object_type_id>`, `    <primary_id>${escapeXml(part.context.ref.primaryId)}</primary_id>`, "  </object_context>");
-      continue;
-    }
-    lines.push("  <app_state_context>", `    <id>${escapeXml(part.context.id)}</id>`, `    <description>${escapeXml(part.context.description)}</description>`, `    <value format="json">${escapeXml(stableJsonStringify(part.context.value))}</value>`, "  </app_state_context>");
-  }
-  lines.push("</sixb_user_context>");
-  return lines.join(`
-`);
-}
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-
-// src/agents/tool-result.ts
-function isAgentToolResult(value) {
-  return isPlainRecord(value) && value.kind === "agentToolResult" && getInvalidAgentToolResultReason(value) === undefined;
-}
-function getInvalidAgentToolResultReason(value) {
-  if (!isPlainRecord(value) || value.kind !== "agentToolResult") {
-    return;
-  }
-  if (!Array.isArray(value.content)) {
-    return "result.content must be an array";
-  }
-  const unsupportedKey = Object.keys(value).find((key) => key !== "kind" && key !== "content");
-  if (unsupportedKey) {
-    return `result.${unsupportedKey} is not supported`;
-  }
-  if (value.content.length === 0) {
-    return "result.content must contain at least one content part";
-  }
-  for (let index = 0;index < value.content.length; index += 1) {
-    const part = value.content[index];
-    const path = `result.content[${index}]`;
-    if (!isPlainRecord(part)) {
-      return `${path} must be a text or file content part`;
-    }
-    if (part.type === "text") {
-      if (typeof part.text !== "string") {
-        return `${path}.text must be a string`;
-      }
-      const unsupportedKey2 = Object.keys(part).find((key) => key !== "type" && key !== "text");
-      if (unsupportedKey2) {
-        return `${path}.${unsupportedKey2} is not supported`;
-      }
-      continue;
-    }
-    if (part.type === "file") {
-      if (!isFileRef(part.fileRef)) {
-        return `${path}.fileRef must be a valid FileRef`;
-      }
-      const unsupportedKey2 = Object.keys(part).find((key) => key !== "type" && key !== "fileRef");
-      if (unsupportedKey2) {
-        return `${path}.${unsupportedKey2} is not supported`;
-      }
-      continue;
-    }
-    return `${path}.type must be 'text' or 'file'`;
-  }
-  return;
-}
-
-// src/agents/adapters.ts
-var TOOL_TYPE_PREFIX = "tool-";
-function assertAdapter(condition, message) {
-  if (!condition) {
-    throw new AgentMessageAdapterError(`[Sixb] ${message}`);
-  }
-}
-function requireJson(value, label) {
-  const reason = getInvalidJsonValueReason(value, label);
-  assertAdapter(reason === undefined, `agent message ${label} must be a JSON value; ${reason}`);
-  return value;
-}
-function optionalJson(value, label) {
-  if (value === undefined)
-    return;
-  return requireJson(omitUndefinedObjectProperties(value), label);
-}
-function optionalProviderData(value, label) {
-  const json = optionalJson(value, label);
-  if (json === undefined)
-    return;
-  assertAdapter(isPlainRecord(json), `agent message ${label} must be a provider-keyed JSON object`);
-  return json;
-}
-function omitUndefinedObjectProperties(value) {
-  return omitUndefinedObjectPropertiesInternal(value, new Set);
-}
-function omitUndefinedObjectPropertiesInternal(value, seen) {
-  if (typeof value !== "object" || value === null)
-    return value;
-  if (seen.has(value))
-    return value;
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      return value.map((entry) => omitUndefinedObjectPropertiesInternal(entry, seen));
-    }
-    if (!isPlainRecord(value))
-      return value;
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, omitUndefinedObjectPropertiesInternal(entry, seen)]));
-  } finally {
-    seen.delete(value);
-  }
-}
-function isToolType(type) {
-  return type === "dynamic-tool" || type.startsWith(TOOL_TYPE_PREFIX);
-}
-function toolNameFromInbound(part) {
-  if (part.type === "dynamic-tool") {
-    assertAdapter(typeof part.toolName === "string" && part.toolName.length > 0, "dynamic-tool part is missing a tool name");
-    return part.toolName;
-  }
-  const name = part.type.slice(TOOL_TYPE_PREFIX.length);
-  assertAdapter(name.length > 0, `tool part type '${part.type}' is missing a tool name`);
-  return name;
-}
-function fromUiMessage(message) {
-  const { role } = message;
-  assertAdapter(role === "system" || role === "user" || role === "assistant", `unsupported message role '${role}'`);
-  const parts = message.parts.map((part) => fromUiMessagePart(part));
-  assertAdapter(role === "user" || !parts.some((part) => part.type === "context"), "context parts are only valid on user messages");
-  const metadata = optionalJson(message.metadata, "metadata");
-  return {
-    role,
-    parts,
-    ...metadata === undefined ? {} : { metadata }
-  };
-}
-function fromUiMessagePart(part) {
-  switch (part.type) {
-    case "text":
-    case "reasoning": {
-      assertAdapter(typeof part.text === "string", `${part.type} part is missing text`);
-      assertAdapter(part.state !== "streaming", `cannot persist a streaming ${part.type} part; messages are written only once finalized`);
-      const providerMetadata = optionalProviderData(part.providerMetadata, `${part.type}.providerMetadata`);
-      return {
-        type: part.type,
-        text: part.text,
-        ...providerMetadata === undefined ? {} : { providerMetadata }
-      };
-    }
-    case "step-start":
-      return { type: "step-start" };
-    case "file": {
-      assertAdapter(isFileRef(part.fileRef), "file part is missing a valid fileRef");
-      const providerMetadata = optionalProviderData(part.providerMetadata, "file.providerMetadata");
-      return {
-        type: "file",
-        fileRef: part.fileRef,
-        ...providerMetadata === undefined ? {} : { providerMetadata }
-      };
-    }
-    case "context":
-      return fromUiContextPart(part);
-    case "provider-state":
-      assertAdapter(typeof part.providerId === "string" && part.providerId.length > 0, "provider-state part is missing a provider id");
-      return {
-        type: "provider-state",
-        providerId: part.providerId,
-        data: requireJson(part.data, "provider-state data")
-      };
-    default: {
-      assertAdapter(isToolType(part.type), `unsupported message part type '${part.type}'; extend the Sixb message part union to support it`);
-      return fromUiToolPart(part);
-    }
-  }
-}
-function fromUiContextPart(part) {
-  try {
-    const [entry] = normalizeAgentContextEntries([
-      { context: part.context, origin: part.origin }
-    ]);
-    return { type: "context", ...entry };
-  } catch (error) {
-    throw new AgentMessageAdapterError(error instanceof Error ? error.message : "[Sixb] Invalid agent context part.");
-  }
-}
-function fromUiToolPart(part) {
-  const dynamic = part.type === "dynamic-tool";
-  const toolName = toolNameFromInbound(part);
-  assertAdapter(typeof part.toolCallId === "string" && part.toolCallId.length > 0, `tool part '${part.type}' is missing a toolCallId`);
-  assertAdapter(part.state === "output-available" || part.state === "output-error", `cannot persist tool part '${part.toolCallId}' in transient state '${part.state}'; only terminal states are stored`);
-  const input = part.input === undefined ? null : requireJson(part.input, "tool input");
-  const providerMetadata = optionalProviderData(part.callProviderMetadata, "tool callProviderMetadata");
-  const base = {
-    type: "tool-call",
-    toolCallId: part.toolCallId,
-    toolName,
-    input,
-    ...dynamic ? { dynamic: true } : {},
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...providerMetadata === undefined ? {} : { providerMetadata }
-  };
-  if (part.state === "output-available") {
-    return { ...base, state: "output-available", output: requireJson(part.output, "tool output") };
-  }
-  assertAdapter(typeof part.errorText === "string", `tool part '${part.toolCallId}' is missing errorText`);
-  return { ...base, state: "output-error", errorText: part.errorText };
-}
-function toUiMessage(message) {
-  return {
-    role: message.role,
-    parts: message.parts.map((part) => toUiPart(part)),
-    ...message.metadata === undefined ? {} : { metadata: message.metadata }
-  };
-}
-function toUiPart(part) {
-  switch (part.type) {
-    case "text":
-    case "reasoning":
-      return {
-        type: part.type,
-        text: part.text,
-        ...part.providerMetadata === undefined ? {} : { providerMetadata: part.providerMetadata }
-      };
-    case "step-start":
-      return { type: "step-start" };
-    case "file":
-      return {
-        type: "file",
-        fileRef: part.fileRef,
-        ...part.providerMetadata === undefined ? {} : { providerMetadata: part.providerMetadata }
-      };
-    case "context":
-      return { type: "context", context: part.context, origin: part.origin };
-    case "provider-state":
-      return {
-        type: "provider-state",
-        providerId: part.providerId,
-        data: part.data
-      };
-    case "tool-call":
-      return toUiToolPart(part);
-  }
-}
-function toUiToolPart(part) {
-  const body = {
-    toolCallId: part.toolCallId,
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...part.providerMetadata === undefined ? {} : { callProviderMetadata: part.providerMetadata }
-  };
-  const state = part.state === "output-available" ? { state: "output-available", input: part.input, output: part.output } : { state: "output-error", input: part.input, errorText: part.errorText };
-  if (part.dynamic) {
-    return { type: "dynamic-tool", toolName: part.toolName, ...body, ...state };
-  }
-  return { type: `tool-${part.toolName}`, ...body, ...state };
-}
-function toModelMessages(messages, options = {}) {
-  const result = [];
-  for (const message of messages) {
-    switch (message.role) {
-      case "system":
-        result.push(systemModelMessage(message));
-        break;
-      case "user":
-        result.push(userModelMessage(message, options));
-        break;
-      case "assistant":
-        appendAssistantModelMessages(result, message, options);
-        break;
-    }
-  }
-  return result;
-}
-function systemModelMessage(message) {
-  const textParts = message.parts.filter(isTextPart);
-  const providerData = mergeProviderMetadata(textParts);
-  return {
-    role: "system",
-    content: textParts.map((part) => part.text).join(""),
-    ...providerData === undefined ? {} : { providerData }
-  };
-}
-function mergeProviderMetadata(parts) {
-  let merged;
-  for (const part of parts) {
-    const meta = part.providerMetadata;
-    if (meta !== undefined && typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
-      merged = { ...merged ?? {}, ...meta };
-    }
-  }
-  return merged;
-}
-function userModelMessage(message, options) {
-  const content = [];
-  const serializedContext = serializeAgentContextForModel(message.parts.filter((part) => part.type === "context"));
-  if (serializedContext) {
-    content.push({ type: "text", text: `${serializedContext}
-
-` });
-  }
-  message.parts.forEach((part, partIndex) => {
-    if (part.type === "text") {
-      content.push({
-        type: "text",
-        text: part.text,
-        ...part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }
-      });
-      return;
-    }
-    if (part.type === "file") {
-      const fileContext = options.fileText?.({ message, part, partIndex });
-      if (fileContext) {
-        content.push({ type: "text", text: fileContext });
-      }
-      const resolved = options.fileData?.({ message, part, partIndex });
-      if (resolved) {
-        const projection = resolved instanceof URL ? { data: resolved } : resolved;
-        content.push({
-          type: "file",
-          data: projection.data,
-          mediaType: projection.mediaType ?? part.fileRef.mediaType ?? "application/octet-stream",
-          ...projection.filename !== undefined ? { filename: projection.filename } : part.fileRef.fileName === undefined ? {} : { filename: part.fileRef.fileName },
-          ...part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }
-        });
-      }
-    }
-  });
-  return { role: "user", content };
-}
-function appendAssistantModelMessages(result, message, options) {
-  let block = [];
-  const flush = () => {
-    if (block.length === 0) {
-      return;
-    }
-    const current = block;
-    block = [];
-    const content = [];
-    for (const { part, partIndex } of current) {
-      if (part.type === "text") {
-        content.push({
-          type: "text",
-          text: part.text,
-          ...part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }
-        });
-      } else if (part.type === "reasoning") {
-        content.push({
-          type: "reasoning",
-          text: part.text,
-          ...part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }
-        });
-      } else if (part.type === "file") {
-        const fileContext = options.fileText?.({ message, part, partIndex });
-        if (fileContext) {
-          content.push({ type: "text", text: fileContext });
-        }
-      } else if (part.type === "tool-call") {
-        content.push(toolCallModelPart(part));
-        if (part.providerExecuted === true) {
-          content.push(toolResultModelPart(message, part, partIndex, "json", options));
-        }
-      } else if (part.type === "provider-state") {
-        content.push({
-          type: "provider-state",
-          providerId: part.providerId,
-          data: part.data
-        });
-      }
-    }
-    result.push({ role: "assistant", content });
-    const toolResults = current.flatMap(({ part, partIndex }) => part.type === "tool-call" && part.providerExecuted !== true ? [toolResultModelPart(message, part, partIndex, "text", options)] : []);
-    if (toolResults.length > 0) {
-      result.push({ role: "tool", content: toolResults });
-    }
-  };
-  message.parts.forEach((part, partIndex) => {
-    if (part.type === "step-start") {
-      flush();
-    } else {
-      block.push({ part, partIndex });
-    }
-  });
-  flush();
-}
-function toolCallModelPart(part) {
-  return {
-    type: "tool-call",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    input: part.input,
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }
-  };
-}
-function toolResultModelPart(message, part, partIndex, errorMode, options) {
-  return {
-    type: "tool-result",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    output: toolResultOutput(message, part, partIndex, errorMode, options)
-  };
-}
-function toolResultOutput(message, part, partIndex, errorMode, options) {
-  if (part.state === "output-error") {
-    return errorMode === "json" ? { type: "error-json", value: part.errorText } : { type: "error-text", value: part.errorText };
-  }
-  if (isAgentToolResult(part.output)) {
-    const value = [];
-    part.output.content.forEach((contentPart, contentIndex) => {
-      if (contentPart.type === "text") {
-        value.push(contentPart.text);
-        return;
-      }
-      const fileContext = options.toolResultFileText?.({
-        message,
-        part,
-        partIndex,
-        contentPart,
-        contentIndex
-      });
-      value.push(fileContext ?? toolResultFileFallbackText(contentPart));
-    });
-    return { type: "text", value: value.join(`
-`) };
-  }
-  return typeof part.output === "string" ? { type: "text", value: part.output } : { type: "json", value: part.output };
-}
-function toolResultFileFallbackText(part) {
-  const attributes = [
-    part.fileRef.fileName ? `name=${JSON.stringify(part.fileRef.fileName)}` : undefined,
-    part.fileRef.mediaType ? `mediaType=${JSON.stringify(part.fileRef.mediaType)}` : undefined,
-    `sizeBytes=${part.fileRef.sizeBytes}`
-  ].filter((value) => value !== undefined);
-  return `[Tool-created file: ${attributes.join(" ")}. Contents are not available inline.]`;
-}
-function isTextPart(part) {
-  return part.type === "text";
-}
-// src/agents/api-gateway.ts
-import { createHmac, timingSafeEqual } from "crypto";
-var AGENT_API_GATEWAY_PREFIX = "/__sixb/agent-api";
-var AGENT_API_GATEWAY_CAPABILITY_PREFIX = "sixb_agw_v1_";
-var AGENT_API_ROUTES = SIXB_API_ROUTES.filter((route) => route.agentApi).map((route) => ({ method: route.method, path: route.path }));
-function createAgentApiGatewayCapability(input) {
-  return `${AGENT_API_GATEWAY_CAPABILITY_PREFIX}${capabilityDigest(input)}`;
-}
-function isValidAgentApiGatewayCapability(input) {
-  const expected = createAgentApiGatewayCapability(input);
-  const actual = input.capability;
-  const expectedBuffer = Buffer.from(expected);
-  const actualBuffer = Buffer.from(actual);
-  return expectedBuffer.byteLength === actualBuffer.byteLength && timingSafeEqual(expectedBuffer, actualBuffer);
-}
-function isAllowedAgentApiRequest(method, pathname) {
-  const normalizedMethod = method.toUpperCase();
-  const normalizedPath = normalizeRoutePath(pathname);
-  return AGENT_API_ROUTES.some((route) => route.method === normalizedMethod && matchesPathPattern(normalizedPath, route.path));
-}
-function capabilityDigest(input) {
-  return createHmac("sha256", input.executionToken).update(`agent-api-gateway:${input.projectId}:${input.runId}`).digest("base64url");
-}
-// src/agents/validation.ts
-var AGENT_TOOL_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
-var AGENT_TOOL_PRIMITIVE_SCHEMAS = new Set([
-  "string",
-  "integer",
-  "double",
-  "decimal",
-  "boolean",
-  "date",
-  "timestamp",
-  "uuid",
-  "fileRef"
-]);
-var AGENT_RESERVED_TOOL_NAMES = [
-  "bash",
-  "read",
-  "view_file",
-  "spawn_agent",
-  "wait_agent"
-];
-function isAgentToolDefinition(value) {
-  return isRecord(value) && value.kind === "agentTool" && typeof value.name === "string" && typeof value.description === "string" && isPlainRecord(value.input) && typeof value.handler === "function";
-}
-function assertValidAgentToolName(name) {
-  if (typeof name !== "string" || !AGENT_TOOL_NAME_PATTERN.test(name)) {
-    throw new AgentDefinitionError("[Sixb] Agent tool name must be 1-64 characters, start with a letter or underscore, and contain only letters, numbers, underscores, or hyphens.");
-  }
-  if (AGENT_RESERVED_TOOL_NAMES.includes(name)) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool name '${name}' is reserved by the framework.`);
-  }
-}
-function assertValidAgentToolDescription(name, description) {
-  if (typeof description !== "string" || !description.trim()) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' description must not be empty.`);
-  }
-}
-function assertValidAgentToolInput(name, input) {
-  if (!isPlainRecord(input)) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' input must be a schema object.`);
-  }
-  for (const [field, schema] of Object.entries(input)) {
-    if (!field.trim()) {
-      throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' input field names must not be empty.`);
-    }
-    assertValidAgentToolSchema(name, schema, `input.${field}`, new Set);
-  }
-}
-function validateAndSnapshotAgentToolInput(toolName, input) {
-  assertValidAgentToolInput(toolName, input);
-  try {
-    return deepFreeze(structuredClone(input));
-  } catch {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${toolName}' input must be safely snapshot-compatible.`);
-  }
-}
-function validateAndNormalizeAgentToolInput(toolName, shape, value, valueTypesById) {
-  const label = `Agent tool '${toolName}' input`;
-  if (!isPlainRecord(value)) {
-    throw new OntologyValidationError(`[Sixb] ${label} must be a JSON object.`);
-  }
-  const reason = getInvalidJsonValueReason(value, label);
-  if (reason) {
-    throw new OntologyValidationError(`[Sixb] ${label} must be JSON-compatible; ${reason}.`);
-  }
-  const schema = {
-    type: "object",
-    properties: Object.fromEntries(Object.entries(shape).map(([field, fieldSchema]) => [
-      field,
-      { schema: fieldSchema, required: true }
-    ]))
-  };
-  validateSchemaValue(schema, value, label, valueTypesById);
-  return deepFreeze(normalizeSchemaValue(schema, value, label, valueTypesById));
-}
-function assertValidAgentToolSchema(toolName, schema, path, visiting) {
-  if (typeof schema === "string") {
-    if (AGENT_TOOL_PRIMITIVE_SCHEMAS.has(schema)) {
-      return;
-    }
-    throw invalidAgentToolSchema(toolName, path);
-  }
-  if (!isPlainRecord(schema) || typeof schema.type !== "string" || visiting.has(schema)) {
-    throw invalidAgentToolSchema(toolName, path);
-  }
-  visiting.add(schema);
-  switch (schema.type) {
-    case "enum": {
-      const values = schema.values;
-      const validValues = isValidAgentToolEnumValues(values, schema.valueType);
-      if (!validValues || new Set(values).size !== values.length) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      break;
-    }
-    case "array":
-      assertValidAgentToolSchema(toolName, schema.items, `${path}.items`, visiting);
-      break;
-    case "map":
-      if (schema.keySchema !== "string") {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      assertValidAgentToolSchema(toolName, schema.valueSchema, `${path}.valueSchema`, visiting);
-      break;
-    case "object": {
-      if (!isPlainRecord(schema.properties)) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      for (const [fieldId, field] of Object.entries(schema.properties)) {
-        if (!fieldId.trim() || !isPlainRecord(field) || !("schema" in field)) {
-          throw invalidAgentToolSchema(toolName, `${path}.properties.${fieldId}`);
-        }
-        if (field.required !== undefined && typeof field.required !== "boolean" || field.nullable !== undefined && typeof field.nullable !== "boolean" || field.description !== undefined && (typeof field.description !== "string" || !field.description.trim())) {
-          throw invalidAgentToolSchema(toolName, `${path}.properties.${fieldId}`);
-        }
-        assertValidAgentToolSchema(toolName, field.schema, `${path}.properties.${fieldId}.schema`, visiting);
-      }
-      break;
-    }
-    case "valueTypeRef":
-      if (typeof schema.valueTypeId !== "string" || !schema.valueTypeId.trim()) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      if (schema._resolved !== undefined) {
-        assertValidAgentToolSchema(toolName, schema._resolved, `${path}._resolved`, visiting);
-      }
-      break;
-    default:
-      throw invalidAgentToolSchema(toolName, path);
-  }
-  visiting.delete(schema);
-}
-function invalidAgentToolSchema(toolName, path) {
-  return new AgentDefinitionError(`[Sixb] Agent tool '${toolName}' ${path} must be a valid Sixb schema.`);
-}
-function assertValidProjectAgentToolDefinitions(tools) {
-  assertValidAgentToolDefinitionList(tools, {
-    invalidDefinitions: "[Sixb] Project tools must contain only agent tool definitions.",
-    duplicateName: (name) => `[Sixb] Project tools contain duplicate tool name '${name}'.`
-  });
-}
-function assertValidAgentToolDefinitionList(tools, messages) {
-  const seen = new Set;
-  for (let index = 0;index < tools.length; index += 1) {
-    const tool = tools[index];
-    if (!Object.hasOwn(tools, index) || !isAgentToolDefinition(tool)) {
-      throw new AgentDefinitionError(messages.invalidDefinitions);
-    }
-    assertValidAgentToolName(tool.name);
-    assertValidAgentToolDescription(tool.name, tool.description);
-    assertValidAgentToolInput(tool.name, tool.input);
-    if (seen.has(tool.name)) {
-      throw new AgentDefinitionError(messages.duplicateName(tool.name));
-    }
-    seen.add(tool.name);
-  }
-}
-function isValidAgentToolEnumValues(values, valueType) {
-  if (!Array.isArray(values) || values.length === 0) {
-    return false;
-  }
-  for (let index = 0;index < values.length; index += 1) {
-    if (!Object.hasOwn(values, index)) {
-      return false;
-    }
-    const value = values[index];
-    if (valueType === "string" ? typeof value !== "string" : valueType !== "integer" || typeof value !== "number" || !Number.isInteger(value)) {
-      return false;
-    }
-  }
-  return true;
-}
-function deepFreeze(value, seen = new Set) {
-  if (value === null || typeof value !== "object" || seen.has(value)) {
-    return value;
-  }
-  seen.add(value);
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor && "value" in descriptor) {
-      deepFreeze(descriptor.value, seen);
-    }
-  }
-  return Object.freeze(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/agents/tool-definition.ts
-var EMPTY_AGENT_TOOLS = Object.freeze([]);
-var normalizedAgentTools = new WeakSet;
-function createAgentToolDefinition(definition) {
-  assertValidAgentToolName(definition.name);
-  assertValidAgentToolDescription(definition.name, definition.description);
-  if (typeof definition.handler !== "function") {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${definition.name}' handler must be a function.`);
-  }
-  const input = validateAndSnapshotAgentToolInput(definition.name, definition.input);
-  const tool = {
-    kind: "agentTool",
-    name: definition.name,
-    description: definition.description,
-    input,
-    handler: async (context) => {
-      const result = await definition.handler(context);
-      let snapshot;
-      try {
-        snapshot = cloneJsonValue(result, "result");
-      } catch (cause) {
-        throw new AgentToolResultValidationError(definition.name, getInvalidJsonValueReason(result, "result") ?? "result could not be cloned safely", { cause });
-      }
-      const richResultReason = getInvalidAgentToolResultReason(snapshot);
-      if (richResultReason) {
-        throw new AgentToolResultValidationError(definition.name, richResultReason);
-      }
-      return snapshot;
-    }
-  };
-  normalizedAgentTools.add(tool);
-  return Object.freeze(tool);
-}
-function toolsFromProjectConfig(tools) {
-  if (tools === undefined) {
-    return EMPTY_AGENT_TOOLS;
-  }
-  if (!Array.isArray(tools)) {
-    throw new AgentDefinitionError("[Sixb] Project tools must be an array of agent tool definitions.");
-  }
-  assertValidProjectAgentToolDefinitions(tools);
-  return normalizeAgentToolDefinitions(tools);
-}
-function normalizeAgentToolDefinitions(tools) {
-  const normalized = [];
-  for (const tool of tools) {
-    normalized.push(normalizeAgentToolDefinition(tool));
-  }
-  return Object.freeze(normalized);
-}
-function normalizeAgentToolDefinition(tool) {
-  if (normalizedAgentTools.has(tool)) {
-    return tool;
-  }
-  return createAgentToolDefinition({
-    name: tool.name,
-    description: tool.description,
-    input: tool.input,
-    handler: (context) => tool.handler(context)
-  });
-}
-
-// src/agents/builders.ts
-function defineAgentTool(name) {
-  assertValidAgentToolName(name);
-  return {
-    description(description) {
-      assertValidAgentToolDescription(name, description);
-      return {
-        input(input) {
-          assertValidAgentToolInput(name, input);
-          return {
-            run(handler) {
-              return createAgentToolDefinition({ name, description, input, handler });
-            }
-          };
-        }
-      };
-    }
-  };
-}
-// src/agents/context-compaction.ts
-var AGENT_CONTEXT_ESTIMATOR_VERSION = 1;
-var CHARS_PER_TOKEN = 4;
-var REQUEST_OVERHEAD_TOKENS = 8;
-var MESSAGE_OVERHEAD_TOKENS = 8;
-var TOOL_OVERHEAD_TOKENS = 16;
-var STEP_OVERHEAD_TOKENS = 2;
-var IMAGE_ALLOWANCE_TOKENS = 1200;
-var FILE_TEXT_INLINE_MAX_BYTES = 50 * 1024;
-var FILE_TEXT_INLINE_TOTAL_MAX_BYTES = 200 * 1024;
-var TOOL_RESULT_SUMMARY_MAX_CHARS = 2000;
-function shouldCompactAgentContext(input) {
-  return input.estimatedInputTokens > input.inputBudgetTokens;
-}
-function estimateAgentContextRequestTokens(input) {
-  const toolTokens = input.tools.reduce((total, tool) => total + TOOL_OVERHEAD_TOKENS + textTokens(tool.name) + textTokens(tool.description) + textTokens(tool.inputSchema), 0);
-  return {
-    tokens: REQUEST_OVERHEAD_TOKENS + textTokens(input.systemPrompt) + toolTokens + estimateAgentContextMessagesTokens(input.messages).tokens,
-    estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION
-  };
-}
-function estimateAgentContextMessagesTokens(messages) {
-  const attachments = { textBytesRemaining: FILE_TEXT_INLINE_TOTAL_MAX_BYTES };
-  let tokens = 0;
-  for (const message of messages) {
-    tokens += estimateMessageTokens(message, attachments);
-  }
-  return { tokens, estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION };
-}
-function selectAgentContextCompactionBoundary(input) {
-  if (input.messages.length < 2)
-    return null;
-  let retainedTokens = 0;
-  let boundaryIndex = null;
-  let closestDistance = Number.POSITIVE_INFINITY;
-  for (let index = input.messages.length - 1;index > 0; index -= 1) {
-    retainedTokens += estimateAgentContextMessagesTokens([input.messages[index]]).tokens;
-    if (input.messages[index]?.role !== "user")
-      continue;
-    const distance = Math.abs(input.keepRecentTokens - retainedTokens);
-    if (distance <= closestDistance) {
-      boundaryIndex = index;
-      closestDistance = distance;
-    }
-    if (retainedTokens >= input.keepRecentTokens)
-      break;
-  }
-  if (boundaryIndex === null)
-    return null;
-  const summarizedThroughSeq = input.messages[boundaryIndex - 1]?.seq;
-  if (summarizedThroughSeq === undefined)
-    return null;
-  return {
-    messagesToSummarize: input.messages.slice(0, boundaryIndex),
-    retainedMessages: input.messages.slice(boundaryIndex),
-    summarizedThroughSeq
-  };
-}
-function serializeAgentMessagesForSummary(messages) {
-  const lines = ["<sixb_conversation_history>"];
-  for (const message of messages) {
-    lines.push(`  <message id="${escapeXml2(message.id)}" seq="${message.seq}" role="${message.role}">`);
-    message.parts.forEach((part, partIndex) => {
-      lines.push(...serializeSummaryPart(message, part, partIndex));
-    });
-    lines.push("  </message>");
-  }
-  lines.push("</sixb_conversation_history>");
-  return lines.join(`
-`);
-}
-function estimateMessageTokens(message, attachments) {
-  let tokens = MESSAGE_OVERHEAD_TOKENS;
-  for (const part of message.parts) {
-    switch (part.type) {
-      case "text":
-      case "reasoning":
-        tokens += textTokens(part.text);
-        break;
-      case "step-start":
-        tokens += STEP_OVERHEAD_TOKENS;
-        break;
-      case "context":
-        tokens += textTokens(stableJsonStringify(part.context));
-        break;
-      case "provider-state":
-        tokens += textTokens(stableJsonStringify(part.data));
-        break;
-      case "tool-call":
-        tokens += TOOL_OVERHEAD_TOKENS + textTokens(part.toolName) + textTokens(stableJsonStringify(part.input)) + (part.state === "output-available" ? textTokens(stableJsonStringify(part.output)) : textTokens(part.errorText));
-        break;
-      case "file": {
-        const file = part.fileRef;
-        tokens += textTokens([file.blobId, file.digest, file.fileName, file.mediaType, file.logicalPath].filter((value) => value !== undefined).join(" "));
-        if (message.role !== "assistant") {
-          if (looksLikeImage(file.mediaType, file.fileName)) {
-            tokens += IMAGE_ALLOWANCE_TOKENS;
-          } else {
-            const inlineBytes = Math.min(file.sizeBytes, FILE_TEXT_INLINE_MAX_BYTES, attachments.textBytesRemaining);
-            attachments.textBytesRemaining -= inlineBytes;
-            tokens += Math.ceil(inlineBytes / CHARS_PER_TOKEN);
-          }
-        }
-        break;
-      }
-    }
-  }
-  return tokens;
-}
-function serializeSummaryPart(message, part, partIndex) {
-  const indent = "    ";
-  switch (part.type) {
-    case "text":
-      return [`${indent}<text>${escapeXml2(part.text)}</text>`];
-    case "reasoning":
-    case "provider-state":
-    case "step-start":
-      return [];
-    case "context":
-      return part.context.kind === "object" ? [
-        `${indent}<object_context origin="${part.origin}" object_type_id="${escapeXml2(part.context.ref.objectTypeId)}" primary_id="${escapeXml2(part.context.ref.primaryId)}" />`
-      ] : [
-        `${indent}<app_context origin="${part.origin}" id="${escapeXml2(part.context.id)}" label="${escapeXml2(part.context.label)}">`,
-        `${indent}  <description>${escapeXml2(part.context.description)}</description>`,
-        `${indent}  <value format="json">${escapeXml2(stableJsonStringify(part.context.value))}</value>`,
-        `${indent}</app_context>`
-      ];
-    case "file": {
-      const file = part.fileRef;
-      const attributes = [
-        `message_id="${escapeXml2(message.id)}"`,
-        `part_index="${partIndex}"`,
-        `blob_id="${escapeXml2(file.blobId)}"`,
-        `digest="${escapeXml2(file.digest)}"`,
-        `size_bytes="${file.sizeBytes}"`,
-        ...file.fileName === undefined ? [] : [`file_name="${escapeXml2(file.fileName)}"`],
-        ...file.mediaType === undefined ? [] : [`media_type="${escapeXml2(file.mediaType)}"`],
-        ...file.logicalPath === undefined ? [] : [`logical_path="${escapeXml2(file.logicalPath)}"`]
-      ];
-      return [`${indent}<file ${attributes.join(" ")} />`];
-    }
-    case "tool-call": {
-      const output = part.state === "output-available" ? truncateToolResult(stableJsonStringify(part.output)) : truncateToolResult(part.errorText);
-      return [
-        `${indent}<tool_call id="${escapeXml2(part.toolCallId)}" name="${escapeXml2(part.toolName)}" state="${part.state}">`,
-        `${indent}  <input format="json">${escapeXml2(stableJsonStringify(part.input))}</input>`,
-        `${indent}  <result>${escapeXml2(output)}</result>`,
-        `${indent}</tool_call>`
-      ];
-    }
-  }
-}
-function truncateToolResult(value) {
-  if (value.length <= TOOL_RESULT_SUMMARY_MAX_CHARS)
-    return value;
-  return `${value.slice(0, TOOL_RESULT_SUMMARY_MAX_CHARS)}
-[truncated ${value.length - TOOL_RESULT_SUMMARY_MAX_CHARS} characters]`;
-}
-function looksLikeImage(mediaType, fileName) {
-  if (mediaType?.toLowerCase().startsWith("image/"))
-    return true;
-  return /\.(?:avif|gif|jpe?g|png|webp)$/i.test(fileName ?? "");
-}
-function textTokens(value) {
-  return Math.ceil(new TextEncoder().encode(value).byteLength / CHARS_PER_TOKEN);
-}
-function escapeXml2(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-// src/agents/model-loop.ts
-import { randomUUID } from "crypto";
-var MAX_PROVIDER_DATA_BYTES = 256 * 1024;
-async function runModelLoop(input) {
-  assertLoopInput(input);
-  const tools = indexTools(input.tools ?? []);
-  const toolSpecifications = [...tools.values()].map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema
-  }));
-  let messages = [...input.messages];
-  const steps = [];
-  const generateCallId = input.generateCallId ?? (() => `model_call_${randomUUID()}`);
-  const callIds = new Set;
-  for (let stepIndex = 0;stepIndex < input.maxSteps; stepIndex += 1) {
-    if (input.signal.aborted) {
-      return { status: "aborted", steps, partialContent: [] };
-    }
-    await input.onEvent?.({ type: "start-step" });
-    let requestMessages;
-    try {
-      const prepared = await input.prepareStep?.({
-        stepIndex,
-        messages,
-        model: input.model,
-        signal: input.signal
-      });
-      requestMessages = prepared?.messages ?? messages;
-    } catch (error) {
-      if (!input.signal.aborted && !isAbortError(error))
-        throw error;
-      return { status: "aborted", steps, partialContent: [] };
-    }
-    if (input.signal.aborted) {
-      return { status: "aborted", steps, partialContent: [] };
-    }
-    let requestTools = toolSpecifications;
-    if (input.finalStepInstruction !== undefined && stepIndex === input.maxSteps - 1) {
-      requestMessages = [
-        ...requestMessages,
-        { role: "user", content: [{ type: "text", text: input.finalStepInstruction }] }
-      ];
-      requestTools = [];
-    }
-    const callId = generateCallId();
-    if (!callId || callIds.has(callId)) {
-      throw new ModelStreamError(`[SixbModels] Model call IDs must be nonempty and unique.`);
-    }
-    callIds.add(callId);
-    const accumulator = new StreamAccumulator(input.onEvent);
-    let accepted = false;
-    let cost = { status: "unpriceable", reason: "missing-usage" };
-    let terminalStreamError;
-    try {
-      const stream = await input.model.stream({
-        callId,
-        messages: requestMessages,
-        tools: requestTools,
-        ...input.reasoning === undefined ? {} : { reasoning: input.reasoning },
-        ...input.maxOutputTokens === undefined ? {} : { maxOutputTokens: input.maxOutputTokens },
-        ...input.caching === undefined ? {} : { caching: input.caching },
-        ...input.output === undefined ? {} : {
-          responseFormat: {
-            type: "json",
-            name: input.output.name,
-            ...input.output.description === undefined ? {} : { description: input.output.description },
-            schema: input.output.schema
-          }
-        },
-        signal: input.signal
-      });
-      accepted = true;
-      for await (const event of stream.events) {
-        await accumulator.accept(event);
-      }
-    } catch (error) {
-      const aborted = input.signal.aborted || isAbortError(error);
-      if (accumulator.isFinished()) {
-        if (!aborted)
-          terminalStreamError = { error };
-      } else if (!aborted) {
-        throw error;
-      } else {
-        return {
-          status: "aborted",
-          steps,
-          partialContent: accumulator.partialContent()
-        };
-      }
-    } finally {
-      if (accepted) {
-        const facts = accumulator.accounting();
-        const estimate = accumulator.isFinished() ? estimateModelCall(input.model, facts) : cost;
-        cost = facts.reportedCost ? rateModelCall({ usage: facts.usage, reported: facts.reportedCost }) : estimate;
-        await input.onModelCallEnd?.({
-          callId,
-          providerId: input.model.providerId,
-          modelId: input.model.modelId,
-          responseId: facts.responseId ?? `${callId}:response`,
-          providerIds: facts.providerIds,
-          responseModelId: facts.responseModelId,
-          usage: facts.usage,
-          cost,
-          ...facts.reportedCost === undefined ? {} : { estimate },
-          ...input.reasoning === undefined ? {} : { requestedReasoning: input.reasoning },
-          ...facts.route === undefined ? {} : { route: facts.route }
-        });
-      }
-    }
-    if (input.signal.aborted && !accumulator.isFinished()) {
-      return { status: "aborted", steps, partialContent: accumulator.partialContent() };
-    }
-    const response = accumulator.complete();
-    const responseId = response.responseId ?? `${callId}:response`;
-    if (terminalStreamError)
-      throw terminalStreamError.error;
-    if (response.projectionError)
-      throw response.projectionError;
-    if (input.signal.aborted) {
-      return { status: "aborted", steps, partialContent: response.content };
-    }
-    const localCalls = response.toolCalls.filter((call) => call.part.providerExecuted !== true);
-    if (response.finishReason === "pause" && localCalls.length === 0) {
-      const step2 = modelStep(response, responseId, response.content, cost);
-      steps.push(step2);
-      await input.onStepEnd?.(step2);
-      messages = [...requestMessages, { role: "assistant", content: response.content }];
-      if (stepIndex + 1 === input.maxSteps) {
-        throw new ModelStreamError("[SixbModels] Model reached the step limit while a provider continuation was pending.");
-      }
-      continue;
-    }
-    if (localCalls.length === 0) {
-      const step2 = modelStep(response, responseId, response.content, cost);
-      steps.push(step2);
-      await input.onStepEnd?.(step2);
-      if (input.output) {
-        const text = responseText(response);
-        if (response.finishReason !== "stop") {
-          throw new StructuredOutputError(`[SixbModels] Structured output did not complete successfully (${response.finishReason}).`, structuredOutputErrorContext(input, response, responseId, cost, text));
-        }
-        let raw;
-        try {
-          raw = JSON.parse(text);
-        } catch (error) {
-          throw new StructuredOutputError("[SixbModels] Model did not produce valid JSON output.", {
-            cause: error,
-            ...structuredOutputErrorContext(input, response, responseId, cost, text)
-          });
-        }
-        try {
-          return {
-            status: "completed",
-            output: input.output.validate(raw),
-            steps,
-            finishReason: response.finishReason
-          };
-        } catch (error) {
-          throw new StructuredOutputError("[SixbModels] Structured output validation failed.", {
-            cause: error,
-            ...structuredOutputErrorContext(input, response, responseId, cost, text)
-          });
-        }
-      }
-      const output = responseText(response);
-      return { status: "completed", output, steps, finishReason: response.finishReason };
-    }
-    const toolResults = await Promise.all(localCalls.map((call) => executeToolCall(call, tools, callId, input.signal, input.onEvent)));
-    const step = modelStep(response, responseId, [...response.content, ...toolResults], cost);
-    steps.push(step);
-    await input.onStepEnd?.(step);
-    if (input.signal.aborted) {
-      return {
-        status: "aborted",
-        steps,
-        partialContent: []
-      };
-    }
-    const assistantContent = response.content.filter((part) => part.type !== "tool-result" || part.providerExecuted === true);
-    messages = [
-      ...requestMessages,
-      { role: "assistant", content: assistantContent },
-      { role: "tool", content: toolResults }
-    ];
-    if (stepIndex + 1 === input.maxSteps) {
-      if (input.output) {
-        throw new StructuredOutputError("[SixbModels] Model reached the step limit without structured output.", structuredOutputErrorContext(input, response, responseId, cost, responseText(response)));
-      }
-      const output = responseText(response);
-      return { status: "completed", output, steps, finishReason: response.finishReason };
-    }
-  }
-  throw new ModelStreamError("[SixbModels] Model loop exited without a terminal result.");
-}
-function assertLoopInput(input) {
-  if (input.maxOutputTokens !== undefined && (!Number.isSafeInteger(input.maxOutputTokens) || input.maxOutputTokens <= 0)) {
-    throw new TypeError("[SixbModels] maxOutputTokens must be a positive safe integer.");
-  }
-  if (!Number.isInteger(input.maxSteps) || input.maxSteps <= 0) {
-    throw new TypeError("[SixbModels] maxSteps must be a positive integer.");
-  }
-  if (!input.model.providerId.trim() || !input.model.modelId.trim()) {
-    throw new TypeError("[SixbModels] Model providerId and modelId must not be empty.");
-  }
-  if (input.model.definition.providerId !== input.model.providerId || input.model.definition.modelId !== input.model.modelId) {
-    throw new TypeError(`[SixbModels] Model definition for '${input.model.providerId}/${input.model.modelId}' has a different identity.`);
-  }
-  if (input.output) {
-    if (!input.output.name.trim()) {
-      throw new TypeError("[SixbModels] Structured output names must not be empty.");
-    }
-    assertJsonObject(input.output.schema, "structured output schema");
-  }
-}
-function indexTools(tools) {
-  const result = new Map;
-  for (const tool of tools) {
-    if (!tool.name.trim())
-      throw new TypeError("[SixbModels] Tool names must not be empty.");
-    if (result.has(tool.name)) {
-      throw new TypeError(`[SixbModels] Duplicate tool name '${tool.name}'.`);
-    }
-    assertJsonObject(tool.inputSchema, `tool '${tool.name}' input schema`);
-    result.set(tool.name, tool);
-  }
-  return result;
-}
-function responseText(response) {
-  return response.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-}
-function structuredOutputErrorContext(input, response, responseId, cost, text) {
-  return {
-    text,
-    providerId: input.model.providerId,
-    modelId: input.model.modelId,
-    responseId,
-    ...response.responseModelId === undefined ? {} : { responseModelId: response.responseModelId },
-    finishReason: response.finishReason,
-    usage: response.usage,
-    cost
-  };
-}
-function modelStep(response, responseId, content, cost) {
-  return {
-    content,
-    finishReason: response.finishReason,
-    ...response.rawFinishReason === undefined ? {} : { rawFinishReason: response.rawFinishReason },
-    usage: response.usage,
-    responseId,
-    ...response.responseModelId === undefined ? {} : { responseModelId: response.responseModelId },
-    cost,
-    ...response.route === undefined ? {} : { route: response.route }
-  };
-}
-async function executeToolCall(call, tools, callId, signal, onEvent) {
-  const { part } = call;
-  if (call.inputError) {
-    const errorText = `Tool input is not valid JSON: ${call.inputError.message}`;
-    await onEvent?.({
-      type: "tool-input-error",
-      toolCallId: part.toolCallId,
-      toolName: part.toolName,
-      input: part.input,
-      errorText
-    });
-    return toolErrorResult(part, errorText);
-  }
-  const tool = tools.get(part.toolName);
-  if (!tool) {
-    const errorText = `Tool '${part.toolName}' is not available.`;
-    await onEvent?.({
-      type: "tool-output-error",
-      toolCallId: part.toolCallId,
-      toolName: part.toolName,
-      errorText
-    });
-    return toolErrorResult(part, errorText);
-  }
-  let parsed;
-  try {
-    parsed = tool.parseInput(part.input);
-  } catch (error) {
-    const errorText = error instanceof Error ? error.message : "Tool input validation failed.";
-    await onEvent?.({
-      type: "tool-input-error",
-      toolCallId: part.toolCallId,
-      toolName: part.toolName,
-      input: part.input,
-      errorText
-    });
-    return toolErrorResult(part, errorText);
-  }
-  await onEvent?.({
-    type: "tool-input-available",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    input: part.input
-  });
-  let output;
-  let modelOutput;
-  try {
-    const context = { signal, callId, toolCallId: part.toolCallId };
-    output = await tool.execute(parsed, context);
-    assertJsonValue(output, `tool '${part.toolName}' output`);
-    modelOutput = tool.toModelOutput ? await tool.toModelOutput(output, context) : modelToolOutput(output);
-    validateModelToolOutput(modelOutput, part.toolName);
-  } catch (error) {
-    const errorText = tool.errorText(error);
-    await onEvent?.({
-      type: "tool-output-error",
-      toolCallId: part.toolCallId,
-      toolName: part.toolName,
-      errorText
-    });
-    return toolErrorResult(part, errorText);
-  }
-  await onEvent?.({
-    type: "tool-output-available",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    output
-  });
-  return {
-    type: "tool-result",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    output: modelOutput,
-    ...modelOutputMatchesOriginal(modelOutput, output) ? {} : { originalOutput: output }
-  };
-}
-function validateModelToolOutput(output, toolName) {
-  if (output.type === "text" || output.type === "error-text") {
-    if (typeof output.value !== "string") {
-      throw new TypeError(`[SixbModels] Tool '${toolName}' model output must contain text.`);
-    }
-    return;
-  }
-  assertJsonValue(output.value, `tool '${toolName}' model output`);
-}
-function modelOutputMatchesOriginal(output, original) {
-  if (output.type === "text")
-    return typeof original === "string" && output.value === original;
-  if (output.type === "json")
-    return output.value === original;
-  return false;
-}
-function modelToolOutput(value) {
-  return typeof value === "string" ? { type: "text", value } : { type: "json", value };
-}
-function toolErrorResult(part, errorText) {
-  return {
-    type: "tool-result",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    output: { type: "error-text", value: errorText }
-  };
-}
-
-class StreamAccumulator {
-  onEvent;
-  parts = [];
-  spans = new Map;
-  toolCalls = new Map;
-  started = false;
-  finished = false;
-  finishReason;
-  rawFinishReason;
-  usage = {};
-  responseId;
-  providerIds;
-  responseModelId;
-  projectionError;
-  reportedCost;
-  route;
-  constructor(onEvent) {
-    this.onEvent = onEvent;
-  }
-  isFinished() {
-    return this.finished;
-  }
-  async accept(event) {
-    if (this.finished) {
-      throw new ModelStreamError(`[SixbModels] Received '${event.type}' after stream finish.`);
-    }
-    switch (event.type) {
-      case "stream-start":
-        if (this.started)
-          throw new ModelStreamError("[SixbModels] Duplicate stream-start event.");
-        this.started = true;
-        return;
-      case "response-metadata":
-        this.requireStarted(event.type);
-        this.responseId = event.id ?? this.responseId;
-        if (event.providerIds)
-          this.providerIds = { ...this.providerIds, ...event.providerIds };
-        this.responseModelId = event.modelId ?? this.responseModelId;
-        return;
-      case "text-start":
-        await this.startText(event);
-        return;
-      case "text-delta":
-        await this.appendText(event, "text");
-        return;
-      case "text-end":
-        await this.endText(event, "text");
-        return;
-      case "reasoning-start":
-        await this.startReasoning(event);
-        return;
-      case "reasoning-delta":
-        await this.appendText(event, "reasoning");
-        return;
-      case "reasoning-end":
-        await this.endText(event, "reasoning");
-        return;
-      case "tool-input-start":
-        await this.startTool(event);
-        return;
-      case "tool-input-delta":
-        await this.appendTool(event);
-        return;
-      case "tool-input-end":
-        this.endTool(event);
-        return;
-      case "tool-call":
-        await this.completeTool(event);
-        return;
-      case "tool-result":
-        this.addProviderToolResult(event);
-        return;
-      case "provider-state":
-        if (this.captureProviderState(event.data)) {
-          this.parts.push({
-            type: "provider-state",
-            providerId: event.providerId,
-            data: event.data
-          });
-        }
-        return;
-      case "finish":
-        this.requireStarted(event.type);
-        validateUsage(event.usage);
-        this.captureProviderData(event.providerData);
-        this.finished = true;
-        this.finishReason = event.finishReason;
-        this.rawFinishReason = event.rawFinishReason;
-        this.usage = event.usage;
-        this.reportedCost = event.reportedCost;
-        this.route = event.route;
-        return;
-      case "error":
-        throw event.error instanceof Error ? event.error : new ModelProviderError("[SixbModels] Provider stream failed.", "unknown", "unknown", {
-          cause: event.error
-        });
-    }
-  }
-  complete() {
-    if (!this.started)
-      throw new ModelStreamError("[SixbModels] Stream did not start.");
-    if (!this.finished || !this.finishReason) {
-      throw new ModelStreamError("[SixbModels] Stream ended without a finish event.");
-    }
-    for (const part of this.parts) {
-      if ("complete" in part && !part.complete) {
-        throw new ModelStreamError(`[SixbModels] Stream finished with incomplete ${part.type} content.`);
-      }
-    }
-    const parsed = this.parseParts(false);
-    return {
-      content: parsed.content,
-      toolCalls: parsed.toolCalls,
-      finishReason: this.finishReason,
-      ...this.rawFinishReason === undefined ? {} : { rawFinishReason: this.rawFinishReason },
-      ...this.accounting(),
-      ...this.projectionError === undefined ? {} : { projectionError: this.projectionError }
-    };
-  }
-  accounting() {
-    return {
-      usage: this.usage,
-      ...this.responseId === undefined ? {} : { responseId: this.responseId },
-      ...this.providerIds === undefined ? {} : { providerIds: this.providerIds },
-      ...this.responseModelId === undefined ? {} : { responseModelId: this.responseModelId },
-      ...this.reportedCost === undefined ? {} : { reportedCost: this.reportedCost },
-      ...this.route === undefined ? {} : { route: this.route }
-    };
-  }
-  partialContent() {
-    return this.parseParts(true).content;
-  }
-  parseParts(partial) {
-    const content = [];
-    const toolCalls = [];
-    for (const part of this.parts) {
-      if (part.type === "text") {
-        if ((!partial || part.text.length > 0) && (part.complete || partial)) {
-          content.push({
-            type: "text",
-            text: part.text,
-            ...part.providerData === undefined ? {} : { providerData: part.providerData }
-          });
-        }
-      } else if (part.type === "reasoning") {
-        if (part.complete) {
-          content.push({
-            type: "reasoning",
-            text: part.text,
-            ...part.providerData === undefined ? {} : { providerData: part.providerData }
-          });
-        }
-      } else if (part.type === "tool-call") {
-        if (!part.complete)
-          continue;
-        let value = null;
-        let inputError;
-        try {
-          const parsed = JSON.parse(part.inputText);
-          if (!isJsonValue(parsed))
-            throw new TypeError("input is not a JSON value");
-          value = parsed;
-        } catch (error) {
-          inputError = error instanceof Error ? error : new Error(String(error));
-        }
-        const call = {
-          type: "tool-call",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          input: value,
-          ...part.providerData === undefined ? {} : { providerData: part.providerData },
-          ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-          ...part.dynamic === undefined ? {} : { dynamic: part.dynamic }
-        };
-        content.push(call);
-        toolCalls.push({ part: call, ...inputError === undefined ? {} : { inputError } });
-      } else {
-        content.push(part);
-      }
-    }
-    return { content, toolCalls };
-  }
-  async startText(event) {
-    this.requireStarted(event.type);
-    this.assertNewSpan(event.id);
-    const providerData = this.captureProviderData(event.providerData);
-    const part = {
-      type: "text",
-      text: "",
-      complete: false,
-      ...providerData === undefined ? {} : { providerData }
-    };
-    this.spans.set(event.id, part);
-    this.parts.push(part);
-    await this.onEvent?.({ type: "text-start", id: event.id });
-  }
-  async startReasoning(event) {
-    this.requireStarted(event.type);
-    this.assertNewSpan(event.id);
-    const providerData = this.captureProviderData(event.providerData);
-    const part = {
-      type: "reasoning",
-      text: "",
-      complete: false,
-      ...providerData === undefined ? {} : { providerData }
-    };
-    this.spans.set(event.id, part);
-    this.parts.push(part);
-    await this.onEvent?.({ type: "reasoning-start", id: event.id });
-  }
-  async appendText(event, expected) {
-    const part = this.spans.get(event.id);
-    if (!part || part.type !== expected || part.complete) {
-      throw new ModelStreamError(`[SixbModels] ${event.type} references unopened ${expected} span '${event.id}'.`);
-    }
-    part.text += event.delta;
-    await this.onEvent?.({ type: event.type, id: event.id, delta: event.delta });
-  }
-  async endText(event, expected) {
-    const part = this.spans.get(event.id);
-    if (!part || part.type !== expected || part.complete) {
-      throw new ModelStreamError(`[SixbModels] ${event.type} references unopened ${expected} span '${event.id}'.`);
-    }
-    part.providerData = mergeProviderData(part.providerData, this.captureProviderData(event.providerData));
-    part.complete = true;
-    this.spans.delete(event.id);
-    await this.onEvent?.({ type: event.type, id: event.id });
-  }
-  async startTool(event) {
-    this.requireStarted(event.type);
-    if (!event.id || !event.toolName) {
-      throw new ModelStreamError("[SixbModels] Tool calls require nonempty IDs and names.");
-    }
-    if (this.toolCalls.has(event.id)) {
-      throw new ModelStreamError(`[SixbModels] Duplicate tool call ID '${event.id}'.`);
-    }
-    const providerData = this.captureProviderData(event.providerData);
-    const part = {
-      type: "tool-call",
-      toolCallId: event.id,
-      toolName: event.toolName,
-      inputText: "",
-      complete: false,
-      ...providerData === undefined ? {} : { providerData },
-      ...event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted },
-      ...event.dynamic === undefined ? {} : { dynamic: event.dynamic }
-    };
-    this.toolCalls.set(event.id, part);
-    this.parts.push(part);
-    await this.onEvent?.({
-      type: "tool-input-start",
-      toolCallId: event.id,
-      toolName: event.toolName
-    });
-  }
-  async appendTool(event) {
-    const part = this.toolCalls.get(event.id);
-    if (!part || part.complete) {
-      throw new ModelStreamError(`[SixbModels] tool-input-delta references unopened tool call '${event.id}'.`);
-    }
-    part.inputText += event.delta;
-    await this.onEvent?.({
-      type: "tool-input-delta",
-      toolCallId: event.id,
-      toolName: part.toolName,
-      inputTextDelta: event.delta
-    });
-  }
-  endTool(event) {
-    const part = this.toolCalls.get(event.id);
-    if (!part || part.complete) {
-      throw new ModelStreamError(`[SixbModels] tool-input-end references unopened tool call '${event.id}'.`);
-    }
-    part.providerData = mergeProviderData(part.providerData, this.captureProviderData(event.providerData));
-    part.complete = true;
-  }
-  async completeTool(event) {
-    await this.startTool({
-      type: "tool-input-start",
-      id: event.toolCallId,
-      toolName: event.toolName,
-      ...event.providerData === undefined ? {} : { providerData: event.providerData },
-      ...event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted },
-      ...event.dynamic === undefined ? {} : { dynamic: event.dynamic }
-    });
-    const part = this.toolCalls.get(event.toolCallId);
-    if (!part)
-      throw new ModelStreamError("[SixbModels] Failed to index completed tool call.");
-    part.inputText = event.input;
-    part.complete = true;
-  }
-  addProviderToolResult(event) {
-    if (!this.captureJsonValue(event.output, "provider tool result"))
-      return;
-    const providerData = this.captureProviderData(event.providerData);
-    this.parts.push({
-      type: "tool-result",
-      toolCallId: event.toolCallId,
-      toolName: event.toolName,
-      output: event.isError ? { type: "error-json", value: event.output } : modelToolOutput(event.output),
-      providerExecuted: event.providerExecuted ?? true,
-      ...event.dynamic === undefined ? {} : { dynamic: event.dynamic },
-      ...providerData === undefined ? {} : { providerData }
-    });
-  }
-  captureProviderData(data) {
-    if (data === undefined)
-      return;
-    try {
-      validateProviderData(data);
-      return data;
-    } catch (error) {
-      this.captureProjectionError(error);
-      return;
-    }
-  }
-  captureProviderState(value) {
-    if (!this.captureJsonValue(value, "provider state"))
-      return false;
-    if (JSON.stringify(value).length > MAX_PROVIDER_DATA_BYTES) {
-      this.captureProjectionError(new ModelStreamError(`[SixbModels] Provider state exceeds the ${MAX_PROVIDER_DATA_BYTES}-byte response limit.`));
-      return false;
-    }
-    return true;
-  }
-  captureJsonValue(value, label) {
-    try {
-      assertJsonValue(value, label);
-      return true;
-    } catch (error) {
-      this.captureProjectionError(error);
-      return false;
-    }
-  }
-  captureProjectionError(error) {
-    this.projectionError ??= error instanceof Error ? error : new Error(String(error));
-  }
-  requireStarted(type) {
-    if (!this.started) {
-      throw new ModelStreamError(`[SixbModels] Received '${type}' before stream-start.`);
-    }
-  }
-  assertNewSpan(id) {
-    if (!id)
-      throw new ModelStreamError("[SixbModels] Content span IDs must not be empty.");
-    if (this.spans.has(id)) {
-      throw new ModelStreamError(`[SixbModels] Duplicate open content span '${id}'.`);
-    }
-  }
-}
-function validateUsage(usage) {
-  for (const [key, value] of Object.entries(usage)) {
-    if (key === "raw") {
-      if (value !== undefined)
-        assertJsonValue(value, "raw model usage");
-      continue;
-    }
-    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-      throw new ModelStreamError(`[SixbModels] Usage field '${key}' must be a nonnegative integer.`);
-    }
-  }
-}
-function validateProviderData(data) {
-  if (data === undefined)
-    return;
-  assertJsonValue(data, "provider data");
-  if (typeof data !== "object" || data === null || Array.isArray(data)) {
-    throw new TypeError("[SixbModels] provider data must be a JSON object.");
-  }
-  if (JSON.stringify(data).length > MAX_PROVIDER_DATA_BYTES) {
-    throw new ModelStreamError(`[SixbModels] Provider data exceeds the ${MAX_PROVIDER_DATA_BYTES}-byte response limit.`);
-  }
-}
-function mergeProviderData(first, second) {
-  if (first === undefined)
-    return second;
-  if (second === undefined)
-    return first;
-  return { ...first, ...second };
-}
-function isAbortError(error) {
-  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
-}
-// src/agents/reference.ts
-var agent = Object.freeze({
-  kind: "agent",
-  usage: Object.freeze({ kind: "aiUsage" })
-});
-// src/agents/thread-context-projection.ts
-function projectAgentThreadModelContext(input) {
-  const { checkpoint, messages } = input;
-  if (!checkpoint)
-    return messages;
-  assertConsistentCheckpointProjection(checkpoint, messages);
-  return [
-    {
-      role: "user",
-      parts: [{ type: "text", text: serializeThreadSummary(checkpoint.summary) }]
-    },
-    ...messages
-  ];
-}
-function assertConsistentCheckpointProjection(checkpoint, messages) {
-  if (checkpoint.summaryFormatVersion !== 1 || checkpoint.summary.trim().length === 0) {
-    throw projectionError(checkpoint, "has an invalid summary");
-  }
-  if (checkpoint.summarizedThroughSeq >= checkpoint.observedHeadSeq) {
-    throw projectionError(checkpoint, "does not retain its observed head");
-  }
-  if (messages.length === 0) {
-    throw projectionError(checkpoint, "has no retained messages");
-  }
-  let expectedSeq = checkpoint.summarizedThroughSeq + 1;
-  for (const message of messages) {
-    if (message.projectId !== checkpoint.projectId || message.threadId !== checkpoint.threadId) {
-      throw projectionError(checkpoint, "contains a message from another thread");
-    }
-    if (message.seq !== expectedSeq) {
-      throw projectionError(checkpoint, `has a sequence gap before message '${message.id}'`);
-    }
-    expectedSeq += 1;
-  }
-  if (messages[0]?.role !== "user") {
-    throw projectionError(checkpoint, "does not begin at a user turn boundary");
-  }
-  if ((messages.at(-1)?.seq ?? 0) < checkpoint.observedHeadSeq) {
-    throw projectionError(checkpoint, "ends before the checkpoint's observed head");
-  }
-}
-function serializeThreadSummary(summary) {
-  return [
-    "The earlier conversation was compacted into this continuation summary.",
-    "",
-    "<sixb_thread_summary>",
-    escapeXml3(summary),
-    "</sixb_thread_summary>"
-  ].join(`
-`);
-}
-function projectionError(checkpoint, detail) {
-  return new Error(`[Sixb] Agent context checkpoint '${checkpoint.id}' for thread '${checkpoint.threadId}' ${detail}.`);
-}
-function escapeXml3(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-export { serializeAgentContextForModel, isAgentToolResult, omitUndefinedObjectProperties, fromUiMessage, toUiMessage, toModelMessages, AGENT_API_GATEWAY_PREFIX, AGENT_API_ROUTES, createAgentApiGatewayCapability, isValidAgentApiGatewayCapability, isAllowedAgentApiRequest, AGENT_RESERVED_TOOL_NAMES, isAgentToolDefinition, validateAndNormalizeAgentToolInput, toolsFromProjectConfig, defineAgentTool, AGENT_CONTEXT_ESTIMATOR_VERSION, shouldCompactAgentContext, estimateAgentContextRequestTokens, estimateAgentContextMessagesTokens, selectAgentContextCompactionBoundary, serializeAgentMessagesForSummary, runModelLoop, agent, projectAgentThreadModelContext };
-
-//# debugId=3D89DCE6FB76677D64756E2164756E21