@sixb/core 0.1.8 → 0.1.10

package/dist/chunk-skz0hst3.js

@@ -0,0 +1,788 @@
+// @bun
+import {
+  SIXB_API_ROUTES2,
+  matchesPathPattern2,
+  normalizeRoutePath2
+} from "./chunk-9vx5e9g1.js";
+import {
+  validateSchemaValue2,
+  normalizeSchemaValue2
+} from "./chunk-ms2tmn1k.js";
+import {
+  AgentDefinitionError2,
+  AgentToolResultValidationError2
+} from "./chunk-dmn70ztd.js";
+import {
+  OntologyValidationError2
+} from "./chunk-cqr3acm1.js";
+import {
+  isFileRef2
+} from "./chunk-h3v76ams.js";
+import {
+  cloneJsonValue2,
+  stableJsonStringify2,
+  getInvalidJsonValueReason2,
+  isPlainRecord
+} from "./chunk-wy0qdqfm.js";
+
+// src/agents/context-model.ts
+function serializeAgentContextForModel2(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(stableJsonStringify2(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 isAgentToolResult2(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 unsupportedKey = Object.keys(part).find((key) => key !== "type" && key !== "text");
+      if (unsupportedKey) {
+        return `${path}.${unsupportedKey} is not supported`;
+      }
+      continue;
+    }
+    if (part.type === "file") {
+      if (!isFileRef2(part.fileRef)) {
+        return `${path}.fileRef must be a valid FileRef`;
+      }
+      const unsupportedKey = Object.keys(part).find((key) => key !== "type" && key !== "fileRef");
+      if (unsupportedKey) {
+        return `${path}.${unsupportedKey} is not supported`;
+      }
+      continue;
+    }
+    return `${path}.type must be 'text' or 'file'`;
+  }
+  return;
+}
+
+// src/agents/adapters.ts
+function toModelMessages2(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((part) => part.type === "text");
+  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 = serializeAgentContextForModel2(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 = [];
+    const toolResults = [];
+    for (const { part, partIndex } of current) {
+      if (part.type === "text" || part.type === "reasoning") {
+        content.push({
+          type: part.type,
+          text: part.text,
+          ...part.providerMetadata === undefined ? {} : { providerData: part.providerMetadata }
+        });
+      } else if (part.type === "tool-call") {
+        content.push(toolCallModelPart(part));
+        if (part.providerExecuted === true) {
+          content.push(toolResultModelPart(message, part, partIndex, "json", options));
+        } else {
+          toolResults.push(toolResultModelPart(message, part, partIndex, "text", options));
+        }
+      } else if (part.type === "provider-state") {
+        content.push({
+          type: "provider-state",
+          providerId: part.providerId,
+          data: part.data
+        });
+      }
+    }
+    if (content.length > 0)
+      result.push({ role: "assistant", content });
+    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 (isAgentToolResult2(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.]`;
+}
+// src/agents/api-gateway.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var AGENT_API_GATEWAY_PREFIX2 = "/__sixb/agent-api";
+var AGENT_API_GATEWAY_CAPABILITY_PREFIX = "sixb_agw_v1_";
+var AGENT_API_ROUTES2 = SIXB_API_ROUTES2.filter((route) => route.agentApi).map((route) => ({ method: route.method, path: route.path }));
+function createAgentApiGatewayCapability2(input) {
+  return `${AGENT_API_GATEWAY_CAPABILITY_PREFIX}${capabilityDigest(input)}`;
+}
+function isValidAgentApiGatewayCapability2(input) {
+  const expected = createAgentApiGatewayCapability2(input);
+  const actual = input.capability;
+  const expectedBuffer = Buffer.from(expected);
+  const actualBuffer = Buffer.from(actual);
+  return expectedBuffer.byteLength === actualBuffer.byteLength && timingSafeEqual(expectedBuffer, actualBuffer);
+}
+function isAllowedAgentApiRequest2(method, pathname) {
+  const normalizedMethod = method.toUpperCase();
+  const normalizedPath = normalizeRoutePath2(pathname);
+  return AGENT_API_ROUTES2.some((route) => route.method === normalizedMethod && matchesPathPattern2(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_NAMES2 = [
+  "bash",
+  "read",
+  "view_file",
+  "spawn_agent",
+  "wait_agent"
+];
+function isAgentToolDefinition2(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 AgentDefinitionError2("[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_NAMES2.includes(name)) {
+    throw new AgentDefinitionError2(`[Sixb] Agent tool name '${name}' is reserved by the framework.`);
+  }
+}
+function assertValidAgentToolDescription(name, description) {
+  if (typeof description !== "string" || !description.trim()) {
+    throw new AgentDefinitionError2(`[Sixb] Agent tool '${name}' description must not be empty.`);
+  }
+}
+function assertValidAgentToolInput(name, input) {
+  if (!isPlainRecord(input)) {
+    throw new AgentDefinitionError2(`[Sixb] Agent tool '${name}' input must be a schema object.`);
+  }
+  for (const [field, schema] of Object.entries(input)) {
+    if (!field.trim()) {
+      throw new AgentDefinitionError2(`[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 AgentDefinitionError2(`[Sixb] Agent tool '${toolName}' input must be safely snapshot-compatible.`);
+  }
+}
+function validateAndNormalizeAgentToolInput2(toolName, shape, value, valueTypesById) {
+  const label = `Agent tool '${toolName}' input`;
+  if (!isPlainRecord(value)) {
+    throw new OntologyValidationError2(`[Sixb] ${label} must be a JSON object.`);
+  }
+  const reason = getInvalidJsonValueReason2(value, label);
+  if (reason) {
+    throw new OntologyValidationError2(`[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 }
+    ]))
+  };
+  validateSchemaValue2(schema, value, label, valueTypesById);
+  return deepFreeze(normalizeSchemaValue2(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 AgentDefinitionError2(`[Sixb] Agent tool '${toolName}' ${path} must be a valid Sixb schema.`);
+}
+function assertValidProjectAgentToolDefinitions(tools) {
+  const seen = new Set;
+  for (let index = 0;index < tools.length; index += 1) {
+    const tool = tools[index];
+    if (!Object.hasOwn(tools, index) || !isAgentToolDefinition2(tool)) {
+      throw new AgentDefinitionError2("[Sixb] Project tools must contain only agent tool definitions.");
+    }
+    assertValidAgentToolName(tool.name);
+    assertValidAgentToolDescription(tool.name, tool.description);
+    assertValidAgentToolInput(tool.name, tool.input);
+    if (seen.has(tool.name)) {
+      throw new AgentDefinitionError2(`[Sixb] Project tools contain duplicate tool name '${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 AgentDefinitionError2(`[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 = cloneJsonValue2(result, "result");
+      } catch (cause) {
+        throw new AgentToolResultValidationError2(definition.name, getInvalidJsonValueReason2(result, "result") ?? "result could not be cloned safely", { cause });
+      }
+      const richResultReason = getInvalidAgentToolResultReason(snapshot);
+      if (richResultReason) {
+        throw new AgentToolResultValidationError2(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 AgentDefinitionError2("[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 defineAgentTool2(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_VERSION2 = 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 shouldCompactAgentContext2(input) {
+  return input.estimatedInputTokens > input.inputBudgetTokens;
+}
+function estimateAgentContextRequestTokens2(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 + estimateAgentContextMessagesTokens2(input.messages).tokens,
+    estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION2
+  };
+}
+function estimateAgentContextMessagesTokens2(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_VERSION2 };
+}
+function selectAgentContextCompactionBoundary2(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 += estimateAgentContextMessagesTokens2([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 serializeAgentMessagesForSummary2(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(stableJsonStringify2(part.context));
+        break;
+      case "provider-state":
+        tokens += textTokens(stableJsonStringify2(part.data));
+        break;
+      case "tool-call":
+        tokens += TOOL_OVERHEAD_TOKENS + textTokens(part.toolName) + textTokens(stableJsonStringify2(part.input)) + (part.state === "output-available" ? textTokens(stableJsonStringify2(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(stableJsonStringify2(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(stableJsonStringify2(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(stableJsonStringify2(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/reference.ts
+var agent2 = Object.freeze({
+  kind: "agent",
+  usage: Object.freeze({ kind: "aiUsage" })
+});
+// src/agents/thread-context-projection.ts
+function projectAgentThreadModelContext2(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 { serializeAgentContextForModel2, isAgentToolResult2, toModelMessages2, AGENT_API_GATEWAY_PREFIX2, AGENT_API_ROUTES2, createAgentApiGatewayCapability2, isValidAgentApiGatewayCapability2, isAllowedAgentApiRequest2, AGENT_RESERVED_TOOL_NAMES2, isAgentToolDefinition2, validateAndNormalizeAgentToolInput2, toolsFromProjectConfig, defineAgentTool2, AGENT_CONTEXT_ESTIMATOR_VERSION2, shouldCompactAgentContext2, estimateAgentContextRequestTokens2, estimateAgentContextMessagesTokens2, selectAgentContextCompactionBoundary2, serializeAgentMessagesForSummary2, agent2, projectAgentThreadModelContext2 };
+
+//# debugId=6ABE14EFB7C9999B64756E2164756E21