@linnlabs/linnkit 0.8.0

package/dist/contracts.cjs

@@ -0,0 +1,1333 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/contracts/messages.ts
+var ProviderReasoningDetails = zod.z.array(zod.z.unknown());
+var ToolCallExtraContent = zod.z.object({
+  google: zod.z.object({
+    thought_signature: zod.z.string().optional()
+  }).passthrough().optional()
+}).passthrough();
+var ToolCallWire = zod.z.object({
+  id: zod.z.string(),
+  type: zod.z.literal("function"),
+  function: zod.z.object({
+    name: zod.z.string(),
+    arguments: zod.z.string()
+  }),
+  extra_content: ToolCallExtraContent.optional()
+}).passthrough();
+var HistorySummaryMeta = zod.z.object({
+  messageType: zod.z.literal("summary"),
+  originalMessageCount: zod.z.number().int().positive(),
+  compressionRatio: zod.z.number().min(0).max(1).optional(),
+  includedOldSummary: zod.z.boolean(),
+  replacedMessageIds: zod.z.array(zod.z.string()),
+  summarySeq: zod.z.number().int().nonnegative()
+});
+var ToolCallsMeta = zod.z.object({
+  tool_calls: zod.z.array(ToolCallWire),
+  reasoning_details: ProviderReasoningDetails.optional()
+});
+var ToolOutputMeta = zod.z.object({
+  tool_name: zod.z.string(),
+  args: zod.z.record(zod.z.unknown()).optional(),
+  tool_call_id: zod.z.string()
+});
+var ImageInfoMeta = zod.z.object({
+  url: zod.z.string().optional(),
+  width: zod.z.number().int().positive().optional(),
+  height: zod.z.number().int().positive().optional(),
+  format: zod.z.string().optional(),
+  size: zod.z.number().int().nonnegative().optional()
+});
+var TaskTrackingMeta = zod.z.object({
+  taskType: zod.z.string().optional(),
+  taskId: zod.z.string().optional(),
+  taskStatus: zod.z.enum(["requested", "in_progress", "completed", "failed"]).optional(),
+  taskTrackingInfo: zod.z.object({
+    startTime: zod.z.number().optional(),
+    endTime: zod.z.number().optional(),
+    duration: zod.z.number().optional(),
+    retryCount: zod.z.number().int().nonnegative().optional(),
+    lastError: zod.z.string().optional()
+  }).optional()
+});
+var PersistentMetadata = zod.z.object({
+  messageType: zod.z.literal("summary").optional(),
+  originalMessageCount: zod.z.number().int().positive().optional(),
+  compressionRatio: zod.z.number().min(0).max(1).optional(),
+  includedOldSummary: zod.z.boolean().optional(),
+  replacedMessageIds: zod.z.array(zod.z.string()).optional(),
+  summarySeq: zod.z.number().int().nonnegative().optional(),
+  tool_calls: zod.z.array(ToolCallWire).optional(),
+  reasoning_details: ProviderReasoningDetails.optional(),
+  tool_name: zod.z.string().optional(),
+  args: zod.z.record(zod.z.unknown()).optional(),
+  tool_call_id: zod.z.string().optional(),
+  raw_output: zod.z.string().optional(),
+  image_info: ImageInfoMeta.optional(),
+  taskType: zod.z.string().optional(),
+  taskId: zod.z.string().optional(),
+  taskStatus: zod.z.enum(["requested", "in_progress", "completed", "failed"]).optional(),
+  taskTrackingInfo: zod.z.object({
+    startTime: zod.z.number().optional(),
+    endTime: zod.z.number().optional(),
+    duration: zod.z.number().optional(),
+    retryCount: zod.z.number().int().nonnegative().optional(),
+    lastError: zod.z.string().optional()
+  }).optional(),
+  fenceKind: zod.z.string().optional(),
+  fenceAttrs: zod.z.record(zod.z.unknown()).optional(),
+  fencePlacement: zod.z.string().optional()
+}).passthrough();
+var BaseMessage = zod.z.object({
+  id: zod.z.string(),
+  content: zod.z.string(),
+  timestamp: zod.z.number().int().nonnegative(),
+  metadata: PersistentMetadata.optional()
+});
+var SystemMessage = BaseMessage.extend({
+  role: zod.z.literal("system"),
+  type: zod.z.enum(["system_prompt", "history_summary", "context_injection"])
+});
+var UserMessage = BaseMessage.extend({
+  role: zod.z.literal("user"),
+  type: zod.z.enum([
+    "user_input",
+    "context_injection",
+    "context_before",
+    "context_after",
+    "document_fragment",
+    "task_request",
+    "image"
+  ])
+});
+var AssistantMessage = BaseMessage.extend({
+  role: zod.z.literal("assistant"),
+  type: zod.z.enum([
+    "thought",
+    "final_answer",
+    "tool_code",
+    "tool_calls",
+    "task_completion"
+  ])
+});
+var ToolMessage = BaseMessage.extend({
+  role: zod.z.literal("tool"),
+  type: zod.z.literal("tool_output")
+});
+var AiMessage = zod.z.discriminatedUnion("role", [
+  SystemMessage,
+  UserMessage,
+  AssistantMessage,
+  ToolMessage
+]);
+function createSystemMessage(type, content, metadata) {
+  return {
+    id: crypto.randomUUID(),
+    role: "system",
+    type,
+    content,
+    timestamp: Date.now(),
+    metadata
+  };
+}
+function createUserMessage(type, content, metadata) {
+  return {
+    id: crypto.randomUUID(),
+    role: "user",
+    type,
+    content,
+    timestamp: Date.now(),
+    metadata
+  };
+}
+function createAssistantMessage(type, content, metadata) {
+  return {
+    id: crypto.randomUUID(),
+    role: "assistant",
+    type,
+    content,
+    timestamp: Date.now(),
+    metadata
+  };
+}
+function createToolMessage(content, toolCallId, toolName, metadata) {
+  return {
+    id: crypto.randomUUID(),
+    role: "tool",
+    type: "tool_output",
+    content,
+    timestamp: Date.now(),
+    metadata: {
+      ...metadata,
+      tool_call_id: toolCallId,
+      tool_name: toolName
+    }
+  };
+}
+function createHistorySummaryMessage(content, summaryMeta) {
+  return {
+    id: crypto.randomUUID(),
+    role: "system",
+    type: "history_summary",
+    content,
+    timestamp: Date.now(),
+    metadata: summaryMeta
+  };
+}
+function validateAiMessage(data) {
+  return AiMessage.safeParse(data);
+}
+function validateHistorySummaryMeta(data) {
+  return HistorySummaryMeta.safeParse(data);
+}
+function isSystemMessage(message) {
+  return message.role === "system";
+}
+function isUserMessage(message) {
+  return message.role === "user";
+}
+function isAssistantMessage(message) {
+  return message.role === "assistant";
+}
+function isToolMessage(message) {
+  return message.role === "tool";
+}
+function isHistorySummaryMessage(message) {
+  return message.role === "system" && message.type === "history_summary" && message.metadata?.messageType === "summary";
+}
+function hasToolCalls(message) {
+  return message.role === "assistant" && Array.isArray(message.metadata?.tool_calls) && message.metadata.tool_calls.length > 0;
+}
+var SerializableJsonValueSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.string(),
+    zod.z.number(),
+    zod.z.boolean(),
+    zod.z.null(),
+    zod.z.array(SerializableJsonValueSchema),
+    zod.z.record(zod.z.string(), SerializableJsonValueSchema)
+  ])
+);
+var SerializableJsonRecord = zod.z.record(zod.z.string(), SerializableJsonValueSchema);
+var AgentSpecMessageType = zod.z.enum([
+  "system_prompt",
+  "history_summary",
+  "context_injection",
+  "user_input",
+  "context_before",
+  "context_after",
+  "document_fragment",
+  "task_request",
+  "image",
+  "thought",
+  "final_answer",
+  "tool_code",
+  "tool_calls",
+  "task_completion",
+  "tool_output"
+]);
+var AgentSpecBudgetPolicy = zod.z.object({
+  maxTokens: zod.z.number().int().positive().optional(),
+  reservedForResponse: zod.z.number().int().nonnegative().optional(),
+  workingMemoryBudgetPercentage: zod.z.number().min(0).max(1).optional()
+});
+var AgentSpecToolHistoryPolicy = zod.z.object({
+  strategy: zod.z.enum(["per-pair", "per-run", "none"]).optional(),
+  keepLatestToolPairs: zod.z.number().int().nonnegative().optional(),
+  keepLatestRuns: zod.z.number().int().nonnegative().optional(),
+  maxInteractionGroups: zod.z.number().int().nonnegative().optional(),
+  overflowStrategy: zod.z.enum(["keep-latest", "fail-fast"]).optional(),
+  maxPairTokens: zod.z.number().int().nonnegative().optional(),
+  maxOutputSummaryTokens: zod.z.number().int().nonnegative().optional()
+});
+var AgentSpecToolObservationGovernancePolicy = zod.z.object({
+  enabled: zod.z.boolean().optional(),
+  maxChars: zod.z.number().int().positive().optional(),
+  maxLines: zod.z.number().int().positive().optional()
+});
+var AgentSpecToolOutputPolicy = zod.z.object({
+  observationGovernance: AgentSpecToolObservationGovernancePolicy.optional()
+});
+var AgentSpecProviderReplayPolicy = zod.z.object({
+  provider: zod.z.string().min(1).optional(),
+  requiresReasoningDetailsForToolReplay: zod.z.boolean().optional(),
+  missingSidecarBehavior: zod.z.enum(["allow", "degrade_to_text", "provider_empty_replay_field"]).optional()
+});
+var AgentSpecSummarizationPolicy = zod.z.object({
+  triggerThreshold: zod.z.number().min(0).max(1).optional(),
+  budgetPercentage: zod.z.number().min(0).max(1).optional(),
+  oldestMessagesPercentage: zod.z.number().min(0).max(1).optional(),
+  agentId: zod.z.string().min(1).optional(),
+  failureBehavior: zod.z.enum(["fail-fast", "continue-if-within-budget"]).optional()
+});
+var AgentSpecMustKeepTruncationRule = zod.z.object({
+  fenceKind: zod.z.string().min(1),
+  maxBudgetFraction: zod.z.number().gt(0).max(1),
+  strategyName: zod.z.string().min(1)
+});
+var AgentSpecMustKeepPolicy = zod.z.object({
+  alwaysKeepTypes: zod.z.array(AgentSpecMessageType).optional(),
+  alwaysKeepFenceKinds: zod.z.array(zod.z.string().min(1)).optional(),
+  truncationRules: zod.z.array(AgentSpecMustKeepTruncationRule).optional()
+});
+var AgentSpecWorkingMemoryPolicy = zod.z.object({
+  maxRecentToolInteractions: zod.z.number().int().nonnegative().optional(),
+  minToolInteractionsToKeep: zod.z.number().int().nonnegative().optional(),
+  toolPairingSearchRange: zod.z.number().int().positive().optional()
+});
+var AgentSpecCheckpointPolicy = zod.z.object({
+  keepPairsBefore: zod.z.number().int().nonnegative().optional(),
+  triggerToolName: zod.z.string().min(1).optional()
+});
+var AgentSpecReasoningRetentionPolicy = zod.z.object({
+  keepLatestThoughts: zod.z.number().int().nonnegative().optional()
+});
+var AgentSpecTokenEstimationPolicy = zod.z.object({
+  encoding: zod.z.string().min(1).optional(),
+  avgCharsPerToken: zod.z.number().positive().optional(),
+  toolCallOverhead: zod.z.number().int().nonnegative().optional()
+});
+var SYSTEM_REMINDER_BUILTIN_TRIGGER_KINDS = [
+  "phase-equals",
+  "remaining-steps-leq",
+  "step-count-modulo",
+  "tool-call-streak",
+  "budget-warning",
+  "agent-has-tool"
+];
+var AgentSpecSystemReminderTrigger = zod.z.object({
+  kind: zod.z.string().min(1),
+  threshold: zod.z.number().nonnegative().optional(),
+  value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean()]).optional(),
+  moduloStep: zod.z.boolean().optional(),
+  toolName: zod.z.string().min(1).optional(),
+  period: zod.z.number().int().positive().optional(),
+  minStep: zod.z.number().int().nonnegative().optional(),
+  ratio: zod.z.number().min(0).max(1).optional(),
+  config: SerializableJsonRecord.optional()
+});
+var AgentSpecSystemReminderExtraRule = zod.z.object({
+  id: zod.z.string().min(1),
+  trigger: AgentSpecSystemReminderTrigger,
+  contentTemplate: zod.z.string().min(1),
+  contentArgs: SerializableJsonRecord.optional()
+});
+var AgentSpecSystemReminderPolicy = zod.z.object({
+  enabledRuleIds: zod.z.array(zod.z.string().min(1)).nullable().optional(),
+  disabledRuleIds: zod.z.array(zod.z.string().min(1)).optional(),
+  thresholds: zod.z.object({
+    toolCallStreak: zod.z.number().int().nonnegative().optional(),
+    taskstateReflectionPeriod: zod.z.number().int().positive().optional(),
+    budgetWarningRatio: zod.z.number().min(0).max(1).optional(),
+    lastStepsHintThreshold: zod.z.number().int().nonnegative().optional()
+  }).optional(),
+  extraRules: zod.z.array(AgentSpecSystemReminderExtraRule).optional()
+}).superRefine((value, ctx) => {
+  if (value.enabledRuleIds !== void 0 && value.enabledRuleIds !== null && value.disabledRuleIds?.length) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["disabledRuleIds"],
+      message: "enabledRuleIds and disabledRuleIds cannot be configured at the same time"
+    });
+  }
+});
+var AgentSpecContextTracePolicy = zod.z.object({
+  enabled: zod.z.boolean().optional(),
+  includeMessageIds: zod.z.boolean().optional(),
+  includeTokenBreakdown: zod.z.boolean().optional(),
+  maxTraceEvents: zod.z.number().int().positive().optional()
+});
+var AgentSpecContextPolicy = zod.z.object({
+  profileId: zod.z.string().min(1),
+  budget: AgentSpecBudgetPolicy.optional(),
+  toolHistory: AgentSpecToolHistoryPolicy.optional(),
+  toolOutput: AgentSpecToolOutputPolicy.optional(),
+  providerReplay: AgentSpecProviderReplayPolicy.optional(),
+  summarization: AgentSpecSummarizationPolicy.optional(),
+  mustKeep: AgentSpecMustKeepPolicy.optional(),
+  workingMemory: AgentSpecWorkingMemoryPolicy.optional(),
+  checkpoint: AgentSpecCheckpointPolicy.optional(),
+  reasoningRetention: AgentSpecReasoningRetentionPolicy.optional(),
+  tokenEstimation: AgentSpecTokenEstimationPolicy.optional(),
+  systemReminder: AgentSpecSystemReminderPolicy.optional(),
+  contextTrace: AgentSpecContextTracePolicy.optional()
+});
+var DEFAULT_CONTEXT_POLICY = {
+  profileId: "agent",
+  budget: {
+    maxTokens: 12e4,
+    reservedForResponse: 2400,
+    workingMemoryBudgetPercentage: 0.7
+  },
+  toolHistory: {
+    strategy: "per-run",
+    keepLatestToolPairs: 2,
+    keepLatestRuns: 1,
+    maxInteractionGroups: 12,
+    overflowStrategy: "keep-latest",
+    maxPairTokens: 6e3,
+    maxOutputSummaryTokens: 1e3
+  },
+  toolOutput: {
+    observationGovernance: {
+      enabled: true,
+      maxChars: 2e4,
+      maxLines: 1200
+    }
+  },
+  providerReplay: {},
+  summarization: {
+    triggerThreshold: 0.7,
+    budgetPercentage: 0.12,
+    oldestMessagesPercentage: 0.75,
+    failureBehavior: "fail-fast"
+  },
+  mustKeep: {
+    alwaysKeepTypes: ["system_prompt", "user_input"],
+    alwaysKeepFenceKinds: [],
+    truncationRules: []
+  },
+  workingMemory: {
+    maxRecentToolInteractions: 2,
+    minToolInteractionsToKeep: 2,
+    toolPairingSearchRange: 10
+  },
+  checkpoint: {
+    keepPairsBefore: 2,
+    triggerToolName: "context_checkpoint"
+  },
+  reasoningRetention: {
+    keepLatestThoughts: 1
+  },
+  tokenEstimation: {
+    encoding: "cl100k_base",
+    avgCharsPerToken: 2,
+    toolCallOverhead: 50
+  },
+  systemReminder: {
+    enabledRuleIds: null,
+    disabledRuleIds: [],
+    thresholds: {
+      toolCallStreak: 10,
+      taskstateReflectionPeriod: 30,
+      budgetWarningRatio: 0.9,
+      lastStepsHintThreshold: 0
+    },
+    extraRules: []
+  },
+  contextTrace: {
+    enabled: false,
+    includeMessageIds: true,
+    includeTokenBreakdown: true,
+    maxTraceEvents: 200
+  }
+};
+function defineContextPolicy(input = {}) {
+  const merged = {
+    profileId: input.profileId ?? DEFAULT_CONTEXT_POLICY.profileId,
+    budget: { ...DEFAULT_CONTEXT_POLICY.budget, ...input.budget },
+    toolHistory: { ...DEFAULT_CONTEXT_POLICY.toolHistory, ...input.toolHistory },
+    toolOutput: {
+      ...DEFAULT_CONTEXT_POLICY.toolOutput,
+      ...input.toolOutput,
+      observationGovernance: {
+        ...DEFAULT_CONTEXT_POLICY.toolOutput.observationGovernance,
+        ...input.toolOutput?.observationGovernance
+      }
+    },
+    providerReplay: { ...DEFAULT_CONTEXT_POLICY.providerReplay, ...input.providerReplay },
+    summarization: { ...DEFAULT_CONTEXT_POLICY.summarization, ...input.summarization },
+    mustKeep: { ...DEFAULT_CONTEXT_POLICY.mustKeep, ...input.mustKeep },
+    workingMemory: { ...DEFAULT_CONTEXT_POLICY.workingMemory, ...input.workingMemory },
+    checkpoint: { ...DEFAULT_CONTEXT_POLICY.checkpoint, ...input.checkpoint },
+    reasoningRetention: { ...DEFAULT_CONTEXT_POLICY.reasoningRetention, ...input.reasoningRetention },
+    tokenEstimation: { ...DEFAULT_CONTEXT_POLICY.tokenEstimation, ...input.tokenEstimation },
+    systemReminder: {
+      ...DEFAULT_CONTEXT_POLICY.systemReminder,
+      ...input.systemReminder,
+      thresholds: {
+        ...DEFAULT_CONTEXT_POLICY.systemReminder.thresholds,
+        ...input.systemReminder?.thresholds
+      },
+      extraRules: input.systemReminder?.extraRules ?? DEFAULT_CONTEXT_POLICY.systemReminder.extraRules
+    },
+    contextTrace: { ...DEFAULT_CONTEXT_POLICY.contextTrace, ...input.contextTrace }
+  };
+  return AgentSpecContextPolicy.parse(merged);
+}
+var JsonRecord = zod.z.record(zod.z.string(), zod.z.unknown());
+var ToolArgsSchemaSpec = JsonRecord.superRefine((value, ctx) => {
+  const parse = value["parse"];
+  const safeParse = value["safeParse"];
+  const definition = value["_def"];
+  if (typeof parse === "function" && typeof safeParse === "function" && definition !== void 0) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "argsSchema must be a serializable record, not a runtime zod schema"
+    });
+  }
+});
+var AgentCapability = zod.z.string().min(1);
+var ToolBindingSpec = zod.z.object({
+  toolId: zod.z.string().min(1),
+  bindingId: zod.z.string().min(1).optional(),
+  argsSchema: ToolArgsSchemaSpec.optional(),
+  config: JsonRecord.optional(),
+  metadata: JsonRecord.optional()
+});
+var AgentSpecModelHints = zod.z.object({
+  preferredProviders: zod.z.array(zod.z.string().min(1)).optional(),
+  preferredModels: zod.z.array(zod.z.string().min(1)).optional(),
+  fallbackChain: zod.z.array(zod.z.string().min(1)).optional()
+});
+var AgentSpecAuditConfig = zod.z.object({
+  redactionLevel: zod.z.enum(["none", "standard", "strict"]).optional(),
+  pii: zod.z.boolean().optional()
+});
+var AgentSpec = zod.z.object({
+  id: zod.z.string().min(1),
+  version: zod.z.string().min(1),
+  role: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  capabilities: zod.z.array(AgentCapability),
+  tools: zod.z.array(ToolBindingSpec),
+  contextPolicy: AgentSpecContextPolicy,
+  modelHints: AgentSpecModelHints.optional(),
+  audit: AgentSpecAuditConfig.optional(),
+  metadata: JsonRecord.optional()
+});
+var JsonRecord2 = zod.z.record(zod.z.string(), zod.z.unknown());
+var AUDIT_ACTIONS = [
+  "model.select",
+  "model.fallback",
+  "tool.allow",
+  "tool.deny",
+  "wait_user.request",
+  "sandbox.decide",
+  "run.cancel",
+  "run.pause",
+  "run.resume",
+  "memory.write"
+];
+var AUDIT_DECISION_OUTCOMES = [
+  "allowed",
+  "denied",
+  "fallback",
+  "retry",
+  "cancelled",
+  "paused",
+  "resumed",
+  "requested",
+  "recorded"
+];
+var AuditActor = zod.z.object({
+  kind: zod.z.enum(["system", "host", "agent", "model", "tool", "user"]),
+  id: zod.z.string().min(1).optional(),
+  name: zod.z.string().min(1).optional()
+});
+var AuditDecision = zod.z.object({
+  outcome: zod.z.enum(AUDIT_DECISION_OUTCOMES),
+  reason: zod.z.string().optional(),
+  policy: zod.z.string().optional(),
+  metadata: JsonRecord2.optional()
+});
+var AuditEvidence = zod.z.object({
+  kind: zod.z.string().min(1),
+  ref: zod.z.string().min(1).optional(),
+  summary: zod.z.string().optional(),
+  metadata: JsonRecord2.optional()
+});
+var AuditCostDelta = zod.z.object({
+  tokensInput: zod.z.number().int().nonnegative().optional(),
+  tokensOutput: zod.z.number().int().nonnegative().optional(),
+  totalCostUsd: zod.z.number().nonnegative().optional(),
+  latencyMs: zod.z.number().nonnegative().optional()
+});
+var AuditScope = zod.z.object({
+  conversationId: zod.z.string().min(1).optional(),
+  runId: zod.z.string().min(1).optional(),
+  parentRunId: zod.z.string().min(1).optional(),
+  turnId: zod.z.string().min(1).optional(),
+  traceId: zod.z.string().min(1).optional(),
+  agentSpecId: zod.z.string().min(1).optional(),
+  toolCallId: zod.z.string().min(1).optional(),
+  toolName: zod.z.string().min(1).optional(),
+  modelId: zod.z.string().min(1).optional(),
+  nodeId: zod.z.string().min(1).optional(),
+  metadata: JsonRecord2.optional()
+});
+var AuditEnvelope = zod.z.object({
+  envelopeId: zod.z.string().min(1),
+  runId: zod.z.string().min(1),
+  parentRunId: zod.z.string().min(1).optional(),
+  ts: zod.z.number().int().nonnegative(),
+  actor: AuditActor,
+  action: zod.z.string().min(1),
+  decision: AuditDecision.optional(),
+  evidence: zod.z.array(AuditEvidence).optional(),
+  costDelta: AuditCostDelta.optional(),
+  scope: AuditScope.optional()
+});
+var BaseEvent = zod.z.object({
+  id: zod.z.string(),
+  conversation_id: zod.z.string(),
+  timestamp: zod.z.number(),
+  metadata: zod.z.record(zod.z.unknown()).optional(),
+  version: zod.z.literal(1).default(1),
+  turn_id: zod.z.string(),
+  ephemeral: zod.z.boolean().optional()
+});
+var ToolCallPhase = zod.z.enum(["start", "update", "complete", "error"]);
+var Status = zod.z.enum(["loading", "success", "error"]);
+var AgentTodoStatus = zod.z.enum(["pending", "in_progress", "completed", "cancelled"]);
+var AgentTodoItem = zod.z.object({
+  id: zod.z.string(),
+  content: zod.z.string(),
+  status: AgentTodoStatus
+});
+var ProviderReasoningDetailsPayload = zod.z.array(zod.z.unknown());
+var ToolCallDecisionPayload = zod.z.object({
+  args: zod.z.record(zod.z.any()).optional(),
+  tool_calls: zod.z.array(zod.z.unknown()).optional(),
+  /**
+   * 不透明 provider reasoning replay blocks。
+   *
+      * RuntimeEvent 层的标准位置是 assistant 产出事件携带 reasoning_details；
+      * context-manager 会把它回放到 AiMessage.metadata.reasoning_details。
+   */
+  reasoning_details: ProviderReasoningDetailsPayload.optional()
+}).passthrough();
+var RuntimeEvent = zod.z.discriminatedUnion("type", [
+  BaseEvent.extend({
+    type: zod.z.literal("user_input"),
+    content: zod.z.string(),
+    raw_content: zod.z.string().optional(),
+    source: zod.z.enum(["user", "editor", "system"]).default("user")
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("thought"),
+    content: zod.z.string(),
+    thought_message_id: zod.z.string().optional(),
+    delta: zod.z.string().optional(),
+    is_complete: zod.z.boolean().default(false)
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("tool_call_decision"),
+    tool_name: zod.z.string(),
+    tool_call_id: zod.z.string(),
+    phase: ToolCallPhase,
+    status: Status,
+    args: zod.z.record(zod.z.any()).optional(),
+    payload: ToolCallDecisionPayload.optional(),
+    parent_tool_call_id: zod.z.string().optional(),
+    meta: zod.z.record(zod.z.any()).optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("tool_process"),
+    tool_name: zod.z.string(),
+    tool_call_id: zod.z.string(),
+    phase: ToolCallPhase,
+    status: Status,
+    args: zod.z.record(zod.z.any()).optional(),
+    payload: zod.z.record(zod.z.any()).optional(),
+    parent_tool_call_id: zod.z.string().optional(),
+    meta: zod.z.record(zod.z.any()).optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("tool_output"),
+    tool_name: zod.z.string(),
+    tool_call_id: zod.z.string(),
+    status: zod.z.enum(["success", "error"]),
+    output: zod.z.any().optional(),
+    payload: zod.z.record(zod.z.any()).optional(),
+    error: zod.z.string().optional(),
+    duration_ms: zod.z.number().optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("todo_updated"),
+    todo_list_id: zod.z.string(),
+    todo_list_version: zod.z.number().int().nonnegative(),
+    items: zod.z.array(AgentTodoItem)
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("subrun_trace"),
+    parent_tool_call_id: zod.z.string(),
+    subrun_id: zod.z.string(),
+    subrun_parent_id: zod.z.string().optional(),
+    kind: zod.z.enum([
+      "thought_delta",
+      "thought_complete",
+      "tool_call_decision",
+      "tool_process",
+      "tool_output",
+      "final_answer_chunk",
+      "final_answer"
+    ]),
+    delta: zod.z.string().optional(),
+    content: zod.z.string().optional(),
+    tool_name: zod.z.string().optional(),
+    tool_call_id: zod.z.string().optional(),
+    phase: ToolCallPhase.optional(),
+    status: Status.optional(),
+    args: zod.z.unknown().optional(),
+    output: zod.z.unknown().optional(),
+    duration_ms: zod.z.number().optional(),
+    meta: zod.z.record(zod.z.unknown()).optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("requires_user_interaction"),
+    form: zod.z.any().optional(),
+    interaction_type: zod.z.string().optional(),
+    prompt: zod.z.string().optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("audit_envelope"),
+    envelope: AuditEnvelope
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("final_answer"),
+    answer_id: zod.z.string(),
+    content: zod.z.string(),
+    is_complete: zod.z.boolean().default(true),
+    reasoning_details: ProviderReasoningDetailsPayload.optional(),
+    meta: zod.z.record(zod.z.any()).optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("final_answer_chunk"),
+    answer_id: zod.z.string(),
+    seq: zod.z.number().int().nonnegative(),
+    content: zod.z.string(),
+    is_last: zod.z.boolean().optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("history_summary"),
+    content: zod.z.string(),
+    replaced_message_ids: zod.z.array(zod.z.string()),
+    summary_seq: zod.z.number().int().nonnegative(),
+    original_message_count: zod.z.number().int().nonnegative().optional(),
+    compression_ratio: zod.z.number().min(0).max(1).optional(),
+    included_old_summary: zod.z.boolean().optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("error"),
+    error: zod.z.string(),
+    details: zod.z.any().optional(),
+    error_code: zod.z.string().optional(),
+    retryable: zod.z.boolean().optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("control"),
+    op: zod.z.enum(["truncate_after", "replace", "redo", "branch"]),
+    target_id: zod.z.string().optional(),
+    reason: zod.z.string().optional(),
+    meta: zod.z.any().optional()
+  }),
+  BaseEvent.extend({
+    type: zod.z.literal("stream_end"),
+    reason: zod.z.enum(["complete", "error", "interrupted", "timeout"]).optional(),
+    reason_message: zod.z.string().optional(),
+    stats: zod.z.object({
+      total_events: zod.z.number().optional(),
+      duration_ms: zod.z.number().optional(),
+      error_count: zod.z.number().optional()
+    }).optional()
+  })
+]);
+var validateRuntimeEvent = (event) => RuntimeEvent.safeParse(event);
+var validateRuntimeEvents = (events) => zod.z.array(RuntimeEvent).safeParse(events);
+var createUserInputEvent = (id, conversationId, turnId, content, options = {}) => ({
+  type: "user_input",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  content,
+  source: "user",
+  ...options
+});
+var createThoughtEvent = (id, conversationId, turnId, content, options = {}) => ({
+  type: "thought",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  content,
+  is_complete: false,
+  ...options
+});
+var createToolCallDecisionEvent = (id, conversationId, turnId, toolName, toolCallId, options = {}) => ({
+  type: "tool_call_decision",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  tool_name: toolName,
+  tool_call_id: toolCallId,
+  phase: "start",
+  status: "loading",
+  ...options
+});
+var createToolProcessEvent = (id, conversationId, turnId, toolName, toolCallId, options = {}) => ({
+  type: "tool_process",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  tool_name: toolName,
+  tool_call_id: toolCallId,
+  phase: "start",
+  status: "loading",
+  ...options
+});
+var createSubRunTraceEvent = (id, conversationId, turnId, parentToolCallId, subrunId, kind, options = {}) => ({
+  type: "subrun_trace",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  ephemeral: true,
+  parent_tool_call_id: parentToolCallId,
+  subrun_id: subrunId,
+  kind,
+  ...options
+});
+var createToolOutputEvent = (id, conversationId, turnId, toolName, toolCallId, output, status = "success", options = {}) => ({
+  type: "tool_output",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  tool_name: toolName,
+  tool_call_id: toolCallId,
+  status,
+  output,
+  ...options
+});
+var createTodoUpdatedEvent = (id, conversationId, turnId, todoListId, todoListVersion, items, options = {}) => ({
+  type: "todo_updated",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  todo_list_id: todoListId,
+  todo_list_version: todoListVersion,
+  items,
+  ...options
+});
+var createFinalAnswerEvent = (id, conversationId, turnId, answerId, content, options = {}) => ({
+  type: "final_answer",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  answer_id: answerId,
+  content,
+  is_complete: true,
+  ...options
+});
+var createAuditEnvelopeEvent = (id, conversationId, turnId, envelope, options = {}) => ({
+  type: "audit_envelope",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: envelope.ts,
+  version: 1,
+  envelope,
+  metadata: {
+    audit_action: envelope.action,
+    run_context: {
+      runId: envelope.runId,
+      parentId: envelope.parentRunId,
+      traceId: envelope.scope?.traceId
+    }
+  },
+  ...options
+});
+var createFinalAnswerChunkEvent = (id, conversationId, turnId, answerId, seq, content, options = {}) => ({
+  type: "final_answer_chunk",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  answer_id: answerId,
+  seq,
+  content,
+  ...options
+});
+var createHistorySummaryEvent = (id, conversationId, turnId, content, replacedMessageIds, summarySeq, options = {}) => ({
+  type: "history_summary",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  content,
+  replaced_message_ids: replacedMessageIds,
+  summary_seq: summarySeq,
+  ...options
+});
+var createErrorEvent = (id, conversationId, turnId, error, options = {}) => ({
+  type: "error",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  error,
+  ...options
+});
+var createStreamEndEvent = (id, conversationId, turnId, options = {}) => ({
+  type: "stream_end",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  ...options
+});
+
+// src/contracts/constants.ts
+var DEFAULT_MAX_STEPS = 80;
+var ExecutionTraceContext = zod.z.object({
+  execution_id: zod.z.string().describe("The unique identifier for a single, complete execution flow."),
+  trace_id: zod.z.string().optional().describe("An optional trace ID for correlating logs in an APM system.")
+});
+var EventEnvelopeSchema = zod.z.object({
+  seq: zod.z.number().int().nonnegative().describe("A monotonically increasing sequence number within a single execution."),
+  timestamp: zod.z.number().describe("The high-precision timestamp of when the event occurred."),
+  trace: ExecutionTraceContext,
+  source: zod.z.string().describe("The origin of the event, e.g., 'ai', 'tool:file_reader', 'system:summary'."),
+  payload: zod.z.unknown(),
+  render_hint: zod.z.object({
+    card: zod.z.enum(["normal", "collapsible", "none", "image", "interactive"]).optional().describe("Hint for how the UI card should be rendered."),
+    content: zod.z.enum(["markdown", "text", "json", "image_url", "code"]).default("text").describe("Hint for how the content itself should be interpreted.")
+  }).optional(),
+  run_location: zod.z.enum(["frontend", "backend"]).optional().describe("Specifies where a tool action should be or was executed.")
+});
+var EventEnvelope = EventEnvelopeSchema;
+var BaseSSEEvent = zod.z.object({
+  id: zod.z.string(),
+  timestamp: zod.z.number(),
+  conversation_id: zod.z.string(),
+  turn_id: zod.z.string(),
+  metadata: zod.z.record(zod.z.unknown()).optional()
+});
+var SSEThoughtEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("thought"),
+  thought_message_id: zod.z.string().optional(),
+  delta: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  is_complete: zod.z.boolean().default(false)
+});
+var SSEFinalAnswerChunkEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("final_answer_chunk"),
+  answer_id: zod.z.string(),
+  seq: zod.z.number().int().nonnegative(),
+  chunk: zod.z.string(),
+  is_last: zod.z.boolean().optional()
+});
+var SSEFinalAnswerEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("final_answer"),
+  answer_id: zod.z.string(),
+  content: zod.z.string(),
+  meta: zod.z.record(zod.z.any()).optional()
+});
+var SSEMarkdownChunkEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("markdown_chunk"),
+  content_type: zod.z.enum(["text", "code", "table", "image"]).default("text"),
+  text: zod.z.string(),
+  seq: zod.z.number().optional()
+});
+var BaseSSEToolLifecycleEvent = BaseSSEEvent.extend({
+  tool_name: zod.z.string(),
+  tool_call_id: zod.z.string(),
+  phase: zod.z.enum(["start", "update", "complete", "error"]),
+  status: zod.z.enum(["loading", "success", "error"]),
+  args: zod.z.any().optional(),
+  payload: zod.z.any().optional(),
+  meta: zod.z.record(zod.z.any()).optional()
+});
+var SSEToolCallDecisionEvent = BaseSSEToolLifecycleEvent.extend({
+  type: zod.z.literal("tool_call_decision")
+});
+var SSEToolProcessEvent = BaseSSEToolLifecycleEvent.extend({
+  type: zod.z.literal("tool_process")
+});
+var SSEToolOutputEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("tool_output"),
+  tool_name: zod.z.string(),
+  tool_call_id: zod.z.string(),
+  status: zod.z.enum(["success", "error"]),
+  output: zod.z.any().optional(),
+  payload: zod.z.record(zod.z.any()).optional(),
+  duration_ms: zod.z.number().optional()
+});
+var SSETodoUpdatedEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("todo_updated"),
+  todo_list_id: zod.z.string(),
+  todo_list_version: zod.z.number().int().nonnegative(),
+  items: zod.z.array(zod.z.object({
+    id: zod.z.string(),
+    content: zod.z.string(),
+    status: zod.z.enum(["pending", "in_progress", "completed", "cancelled"])
+  }))
+});
+var SSESubRunTraceEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("subrun_trace"),
+  parent_tool_call_id: zod.z.string(),
+  subrun_id: zod.z.string(),
+  subrun_parent_id: zod.z.string().optional(),
+  kind: zod.z.enum([
+    "thought_delta",
+    "thought_complete",
+    "tool_call_decision",
+    "tool_process",
+    "tool_output",
+    "final_answer_chunk",
+    "final_answer"
+  ]),
+  delta: zod.z.string().optional(),
+  content: zod.z.string().optional(),
+  tool_name: zod.z.string().optional(),
+  tool_call_id: zod.z.string().optional(),
+  phase: zod.z.enum(["start", "update", "complete", "error"]).optional(),
+  status: zod.z.enum(["loading", "success", "error"]).optional(),
+  args: zod.z.unknown().optional(),
+  output: zod.z.unknown().optional(),
+  duration_ms: zod.z.number().optional(),
+  meta: zod.z.record(zod.z.unknown()).optional()
+});
+var SSERequiresUserInteractionEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("requires_user_interaction"),
+  form: zod.z.any().optional(),
+  interaction_type: zod.z.string().optional(),
+  prompt: zod.z.string().optional()
+});
+var SSEErrorEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("error"),
+  error: zod.z.string(),
+  details: zod.z.any().optional(),
+  error_code: zod.z.string().optional(),
+  retryable: zod.z.boolean().optional()
+});
+var SSEStreamEndEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("stream_end"),
+  reason: zod.z.enum(["complete", "error", "interrupted", "timeout"]).optional(),
+  reason_message: zod.z.string().optional(),
+  stats: zod.z.object({
+    total_events: zod.z.number().optional(),
+    duration_ms: zod.z.number().optional(),
+    error_count: zod.z.number().optional(),
+    benchmark: zod.z.record(zod.z.unknown()).optional()
+  }).optional()
+});
+var SSEHistorySummaryEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("history_summary"),
+  summary_id: zod.z.string(),
+  content: zod.z.string(),
+  original_message_count: zod.z.number().int().nonnegative(),
+  summary_seq: zod.z.number().int().nonnegative()
+});
+var SSESummarizationStartEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("summarization_start"),
+  originalMessages: zod.z.number().optional()
+});
+var SSESummarizationEndEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("summarization_end"),
+  originalMessages: zod.z.number().optional(),
+  compressedMessages: zod.z.number().optional(),
+  compressionRatio: zod.z.string().optional(),
+  timeSaved: zod.z.string().optional()
+});
+var SSESummarizationErrorEvent = BaseSSEEvent.extend({
+  type: zod.z.literal("summarization_error"),
+  error: zod.z.string()
+});
+var SSEEvent = zod.z.discriminatedUnion("type", [
+  SSEThoughtEvent,
+  SSEFinalAnswerChunkEvent,
+  SSEFinalAnswerEvent,
+  SSEMarkdownChunkEvent,
+  SSEToolCallDecisionEvent,
+  SSEToolProcessEvent,
+  SSEToolOutputEvent,
+  SSETodoUpdatedEvent,
+  SSESubRunTraceEvent,
+  SSERequiresUserInteractionEvent,
+  SSEErrorEvent,
+  SSEStreamEndEvent,
+  SSEHistorySummaryEvent,
+  SSESummarizationStartEvent,
+  SSESummarizationEndEvent,
+  SSESummarizationErrorEvent
+]);
+var validateSSEEvent = (event) => SSEEvent.safeParse(event);
+var createSSEThoughtEvent = (id, conversationId, turnId, options = {}) => ({
+  type: "thought",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  is_complete: false,
+  ...options
+});
+var createSSEFinalAnswerChunkEvent = (id, conversationId, turnId, answerId, seq, chunk, options = {}) => ({
+  type: "final_answer_chunk",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  answer_id: answerId,
+  seq,
+  chunk,
+  ...options
+});
+var createSSEFinalAnswerEvent = (id, conversationId, turnId, answerId, content, options = {}) => ({
+  type: "final_answer",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  answer_id: answerId,
+  content,
+  ...options
+});
+var createSSEMarkdownChunkEvent = (id, conversationId, turnId, text, options = {}) => ({
+  type: "markdown_chunk",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  text,
+  content_type: "text",
+  ...options
+});
+var createSSEToolCallDecisionEvent = (id, conversationId, turnId, toolName, toolCallId, phase, status, options = {}) => ({
+  type: "tool_call_decision",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  tool_name: toolName,
+  tool_call_id: toolCallId,
+  phase,
+  status,
+  ...options
+});
+var createSSEToolProcessEvent = (id, conversationId, turnId, toolName, toolCallId, phase, status, options = {}) => ({
+  type: "tool_process",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  tool_name: toolName,
+  tool_call_id: toolCallId,
+  phase,
+  status,
+  ...options
+});
+var createSSEToolOutputEvent = (id, conversationId, turnId, toolName, toolCallId, status, output, options = {}) => ({
+  type: "tool_output",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  tool_name: toolName,
+  tool_call_id: toolCallId,
+  status,
+  output,
+  ...options
+});
+var createSSETodoUpdatedEvent = (id, conversationId, turnId, todoListId, todoListVersion, items, options = {}) => ({
+  type: "todo_updated",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  todo_list_id: todoListId,
+  todo_list_version: todoListVersion,
+  items,
+  ...options
+});
+var createSSESubRunTraceEvent = (id, conversationId, turnId, parentToolCallId, subrunId, kind, options = {}) => ({
+  type: "subrun_trace",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  parent_tool_call_id: parentToolCallId,
+  subrun_id: subrunId,
+  kind,
+  ...options
+});
+var createSSERequiresUserInteractionEvent = (id, conversationId, turnId, options = {}) => ({
+  type: "requires_user_interaction",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  ...options
+});
+var createSSEErrorEvent = (id, conversationId, turnId, error, options = {}) => ({
+  type: "error",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  error,
+  ...options
+});
+var createSSEStreamEndEvent = (id, conversationId, turnId, options = {}) => ({
+  type: "stream_end",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  ...options
+});
+var createSSEHistorySummaryEvent = (id, conversationId, turnId, summaryId, content, originalMessageCount, summarySeq, options = {}) => ({
+  type: "history_summary",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  summary_id: summaryId,
+  content,
+  original_message_count: originalMessageCount,
+  summary_seq: summarySeq,
+  ...options
+});
+
+exports.AUDIT_ACTIONS = AUDIT_ACTIONS;
+exports.AUDIT_DECISION_OUTCOMES = AUDIT_DECISION_OUTCOMES;
+exports.AgentCapability = AgentCapability;
+exports.AgentSpec = AgentSpec;
+exports.AgentSpecAuditConfig = AgentSpecAuditConfig;
+exports.AgentSpecBudgetPolicy = AgentSpecBudgetPolicy;
+exports.AgentSpecCheckpointPolicy = AgentSpecCheckpointPolicy;
+exports.AgentSpecContextPolicy = AgentSpecContextPolicy;
+exports.AgentSpecContextTracePolicy = AgentSpecContextTracePolicy;
+exports.AgentSpecMessageType = AgentSpecMessageType;
+exports.AgentSpecModelHints = AgentSpecModelHints;
+exports.AgentSpecMustKeepPolicy = AgentSpecMustKeepPolicy;
+exports.AgentSpecMustKeepTruncationRule = AgentSpecMustKeepTruncationRule;
+exports.AgentSpecProviderReplayPolicy = AgentSpecProviderReplayPolicy;
+exports.AgentSpecReasoningRetentionPolicy = AgentSpecReasoningRetentionPolicy;
+exports.AgentSpecSummarizationPolicy = AgentSpecSummarizationPolicy;
+exports.AgentSpecSystemReminderExtraRule = AgentSpecSystemReminderExtraRule;
+exports.AgentSpecSystemReminderPolicy = AgentSpecSystemReminderPolicy;
+exports.AgentSpecSystemReminderTrigger = AgentSpecSystemReminderTrigger;
+exports.AgentSpecTokenEstimationPolicy = AgentSpecTokenEstimationPolicy;
+exports.AgentSpecToolHistoryPolicy = AgentSpecToolHistoryPolicy;
+exports.AgentSpecToolObservationGovernancePolicy = AgentSpecToolObservationGovernancePolicy;
+exports.AgentSpecToolOutputPolicy = AgentSpecToolOutputPolicy;
+exports.AgentSpecWorkingMemoryPolicy = AgentSpecWorkingMemoryPolicy;
+exports.AgentTodoItem = AgentTodoItem;
+exports.AgentTodoStatus = AgentTodoStatus;
+exports.AiMessage = AiMessage;
+exports.AssistantMessage = AssistantMessage;
+exports.AuditActor = AuditActor;
+exports.AuditCostDelta = AuditCostDelta;
+exports.AuditDecision = AuditDecision;
+exports.AuditEnvelope = AuditEnvelope;
+exports.AuditEvidence = AuditEvidence;
+exports.AuditScope = AuditScope;
+exports.BaseEvent = BaseEvent;
+exports.BaseSSEEvent = BaseSSEEvent;
+exports.DEFAULT_MAX_STEPS = DEFAULT_MAX_STEPS;
+exports.EventEnvelope = EventEnvelope;
+exports.ExecutionTraceContext = ExecutionTraceContext;
+exports.HistorySummaryMeta = HistorySummaryMeta;
+exports.ImageInfoMeta = ImageInfoMeta;
+exports.PersistentMetadata = PersistentMetadata;
+exports.ProviderReasoningDetails = ProviderReasoningDetails;
+exports.ProviderReasoningDetailsPayload = ProviderReasoningDetailsPayload;
+exports.RuntimeEvent = RuntimeEvent;
+exports.SSEErrorEvent = SSEErrorEvent;
+exports.SSEEvent = SSEEvent;
+exports.SSEFinalAnswerChunkEvent = SSEFinalAnswerChunkEvent;
+exports.SSEFinalAnswerEvent = SSEFinalAnswerEvent;
+exports.SSEHistorySummaryEvent = SSEHistorySummaryEvent;
+exports.SSEMarkdownChunkEvent = SSEMarkdownChunkEvent;
+exports.SSERequiresUserInteractionEvent = SSERequiresUserInteractionEvent;
+exports.SSEStreamEndEvent = SSEStreamEndEvent;
+exports.SSESubRunTraceEvent = SSESubRunTraceEvent;
+exports.SSESummarizationEndEvent = SSESummarizationEndEvent;
+exports.SSESummarizationErrorEvent = SSESummarizationErrorEvent;
+exports.SSESummarizationStartEvent = SSESummarizationStartEvent;
+exports.SSEThoughtEvent = SSEThoughtEvent;
+exports.SSETodoUpdatedEvent = SSETodoUpdatedEvent;
+exports.SSEToolCallDecisionEvent = SSEToolCallDecisionEvent;
+exports.SSEToolOutputEvent = SSEToolOutputEvent;
+exports.SSEToolProcessEvent = SSEToolProcessEvent;
+exports.SYSTEM_REMINDER_BUILTIN_TRIGGER_KINDS = SYSTEM_REMINDER_BUILTIN_TRIGGER_KINDS;
+exports.Status = Status;
+exports.SystemMessage = SystemMessage;
+exports.TaskTrackingMeta = TaskTrackingMeta;
+exports.ToolBindingSpec = ToolBindingSpec;
+exports.ToolCallDecisionPayload = ToolCallDecisionPayload;
+exports.ToolCallExtraContent = ToolCallExtraContent;
+exports.ToolCallPhase = ToolCallPhase;
+exports.ToolCallWire = ToolCallWire;
+exports.ToolCallsMeta = ToolCallsMeta;
+exports.ToolMessage = ToolMessage;
+exports.ToolOutputMeta = ToolOutputMeta;
+exports.UserMessage = UserMessage;
+exports.createAssistantMessage = createAssistantMessage;
+exports.createAuditEnvelopeEvent = createAuditEnvelopeEvent;
+exports.createErrorEvent = createErrorEvent;
+exports.createFinalAnswerChunkEvent = createFinalAnswerChunkEvent;
+exports.createFinalAnswerEvent = createFinalAnswerEvent;
+exports.createHistorySummaryEvent = createHistorySummaryEvent;
+exports.createHistorySummaryMessage = createHistorySummaryMessage;
+exports.createSSEErrorEvent = createSSEErrorEvent;
+exports.createSSEFinalAnswerChunkEvent = createSSEFinalAnswerChunkEvent;
+exports.createSSEFinalAnswerEvent = createSSEFinalAnswerEvent;
+exports.createSSEHistorySummaryEvent = createSSEHistorySummaryEvent;
+exports.createSSEMarkdownChunkEvent = createSSEMarkdownChunkEvent;
+exports.createSSERequiresUserInteractionEvent = createSSERequiresUserInteractionEvent;
+exports.createSSEStreamEndEvent = createSSEStreamEndEvent;
+exports.createSSESubRunTraceEvent = createSSESubRunTraceEvent;
+exports.createSSEThoughtEvent = createSSEThoughtEvent;
+exports.createSSETodoUpdatedEvent = createSSETodoUpdatedEvent;
+exports.createSSEToolCallDecisionEvent = createSSEToolCallDecisionEvent;
+exports.createSSEToolOutputEvent = createSSEToolOutputEvent;
+exports.createSSEToolProcessEvent = createSSEToolProcessEvent;
+exports.createStreamEndEvent = createStreamEndEvent;
+exports.createSubRunTraceEvent = createSubRunTraceEvent;
+exports.createSystemMessage = createSystemMessage;
+exports.createThoughtEvent = createThoughtEvent;
+exports.createTodoUpdatedEvent = createTodoUpdatedEvent;
+exports.createToolCallDecisionEvent = createToolCallDecisionEvent;
+exports.createToolMessage = createToolMessage;
+exports.createToolOutputEvent = createToolOutputEvent;
+exports.createToolProcessEvent = createToolProcessEvent;
+exports.createUserInputEvent = createUserInputEvent;
+exports.createUserMessage = createUserMessage;
+exports.defineContextPolicy = defineContextPolicy;
+exports.hasToolCalls = hasToolCalls;
+exports.isAssistantMessage = isAssistantMessage;
+exports.isHistorySummaryMessage = isHistorySummaryMessage;
+exports.isSystemMessage = isSystemMessage;
+exports.isToolMessage = isToolMessage;
+exports.isUserMessage = isUserMessage;
+exports.validateAiMessage = validateAiMessage;
+exports.validateHistorySummaryMeta = validateHistorySummaryMeta;
+exports.validateRuntimeEvent = validateRuntimeEvent;
+exports.validateRuntimeEvents = validateRuntimeEvents;
+exports.validateSSEEvent = validateSSEEvent;
+//# sourceMappingURL=contracts.cjs.map
+//# sourceMappingURL=contracts.cjs.map