@linnlabs/linnkit 0.8.0

package/dist/runtime-kernel/events.cjs

@@ -0,0 +1,1485 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/runtime-kernel/events/agentEvents.ts
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isMarkedAsSseDispatched(event) {
+  return isRecord(event) && event["__dispatched_via_sse__"] === true;
+}
+function readAgentEventAnswerId(event) {
+  if (!isRecord(event)) return void 0;
+  const snake = event["answer_id"];
+  if (typeof snake === "string" && snake.trim().length > 0) {
+    return snake.trim();
+  }
+  const camel = event["answerId"];
+  if (typeof camel === "string" && camel.trim().length > 0) {
+    return camel.trim();
+  }
+  return void 0;
+}
+function readAgentEventSeq(event) {
+  if (!isRecord(event)) return void 0;
+  const value = event["seq"];
+  return Number.isInteger(value) ? Number(value) : void 0;
+}
+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();
+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()
+});
+zod.z.object({
+  tool_calls: zod.z.array(ToolCallWire),
+  reasoning_details: ProviderReasoningDetails.optional()
+});
+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()
+});
+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")
+});
+zod.z.discriminatedUnion("role", [
+  SystemMessage,
+  UserMessage,
+  AssistantMessage,
+  ToolMessage
+]);
+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 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 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()
+});
+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_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();
+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 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 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 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 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 createErrorEvent = (id, conversationId, turnId, error, options = {}) => ({
+  type: "error",
+  id,
+  conversation_id: conversationId,
+  turn_id: turnId,
+  timestamp: Date.now(),
+  version: 1,
+  error,
+  ...options
+});
+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.")
+});
+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 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()
+});
+zod.z.discriminatedUnion("type", [
+  SSEThoughtEvent,
+  SSEFinalAnswerChunkEvent,
+  SSEFinalAnswerEvent,
+  SSEMarkdownChunkEvent,
+  SSEToolCallDecisionEvent,
+  SSEToolProcessEvent,
+  SSEToolOutputEvent,
+  SSETodoUpdatedEvent,
+  SSESubRunTraceEvent,
+  SSERequiresUserInteractionEvent,
+  SSEErrorEvent,
+  SSEStreamEndEvent,
+  SSEHistorySummaryEvent,
+  SSESummarizationStartEvent,
+  SSESummarizationEndEvent,
+  SSESummarizationErrorEvent
+]);
+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 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 createSSEErrorEvent = (id, conversationId, turnId, error, options = {}) => ({
+  type: "error",
+  id,
+  timestamp: Date.now(),
+  conversation_id: conversationId,
+  turn_id: turnId,
+  error,
+  ...options
+});
+
+// src/shared/ids.ts
+function isoRandomUUID() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (ch) => {
+    const r = Math.random() * 16 | 0;
+    const v = ch === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function shortRandomId(prefix) {
+  return `${prefix}-${isoRandomUUID().replace(/-/g, "").slice(0, 12)}`;
+}
+function generateMessageId() {
+  return shortRandomId("msg");
+}
+
+// src/runtime-kernel/events/provider-sidecar.ts
+var isRecord2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var isToolCallWire = (value) => {
+  if (!isRecord2(value)) return false;
+  if (typeof value.id !== "string") return false;
+  if (value.type !== "function") return false;
+  const fn = value.function;
+  return isRecord2(fn) && typeof fn.name === "string" && typeof fn.arguments === "string";
+};
+function resolveToolDisplayOptions(toolName, toolPresentationPort) {
+  return toolPresentationPort?.getDisplayOptions(toolName);
+}
+function readAnswerIdFromEvent(event) {
+  if (!isRecord2(event)) return void 0;
+  const value = event["answerId"];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readMetaFromEvent(event) {
+  if (!isRecord2(event)) return void 0;
+  const value = event["meta"];
+  return isRecord2(value) ? value : void 0;
+}
+
+// src/runtime-kernel/events/agent-to-runtime.ts
+function agentEventToRuntime(agentEvent, context, options = {}) {
+  if (!agentEvent || typeof agentEvent !== "object") return null;
+  if (isRecord2(agentEvent) && agentEvent["type"] === "history_summary") {
+    const evt = agentEvent;
+    if (context.metadata) {
+      evt.metadata = { ...evt.metadata ?? {}, ...context.metadata };
+    }
+    return evt;
+  }
+  const typed = agentEvent;
+  const { conversationId, turnId } = context;
+  const timestamp = typed.timestamp ?? context.timestamp ?? Date.now();
+  const id = typed.id ?? generateMessageId();
+  const contextMeta = context.metadata;
+  switch (typed.type) {
+    case "thought":
+      return mapThoughtToRuntime(typed, context, options, id, timestamp);
+    case "tool_call_decision":
+    case "tool_process":
+      return mapToolProgressToRuntime(typed, context, options, id, timestamp);
+    case "observation": {
+      const observationEvent = typed;
+      const toolName = observationEvent.tool_name || "unknown_tool";
+      const toolCallId = observationEvent.tool_call_id || `call_${id}`;
+      const success = observationEvent.success ?? !/^错误[:：]/i.test(String(observationEvent.output ?? ""));
+      const payload = observationEvent.payload || {};
+      const event = createToolOutputEvent(
+        id,
+        conversationId,
+        turnId,
+        toolName,
+        toolCallId,
+        observationEvent.output,
+        success ? "success" : "error",
+        { timestamp, payload, duration_ms: payload.duration_ms }
+      );
+      event.ephemeral = false;
+      if (contextMeta) event.metadata = { ...event.metadata ?? {}, ...contextMeta };
+      return event;
+    }
+    case "final_answer": {
+      const finalAnswerEvent = typed;
+      const answerIdFromSnake = typeof finalAnswerEvent.answer_id === "string" && finalAnswerEvent.answer_id.trim().length > 0 ? finalAnswerEvent.answer_id.trim() : void 0;
+      return createFinalAnswerEvent(
+        id,
+        conversationId,
+        turnId,
+        answerIdFromSnake ?? readAnswerIdFromEvent(finalAnswerEvent) ?? `answer_${turnId}`,
+        finalAnswerEvent.answer ?? "",
+        {
+          timestamp,
+          reasoning_details: Array.isArray(finalAnswerEvent.reasoning_details) ? finalAnswerEvent.reasoning_details : void 0,
+          meta: readMetaFromEvent(finalAnswerEvent)
+        }
+      );
+    }
+    case "error": {
+      const errorEvent = typed;
+      return createErrorEvent(id, conversationId, turnId, errorEvent.error ?? "Unknown error", {
+        timestamp,
+        details: errorEvent.details
+      });
+    }
+    case "stream_chunk":
+      return mapStreamChunkToRuntime(typed, context, id, timestamp);
+    default:
+      return null;
+  }
+}
+function mapThoughtToRuntime(thoughtEvent, context, options, id, timestamp) {
+  const isComplete = "is_complete" in thoughtEvent ? Boolean(thoughtEvent.is_complete) : false;
+  if (options.skipIncomplete && !isComplete) return null;
+  const thoughtMessageId = typeof thoughtEvent.thought_message_id === "string" && thoughtEvent.thought_message_id.length > 0 ? thoughtEvent.thought_message_id : void 0;
+  const runtimeEvent = createThoughtEvent(id, context.conversationId, context.turnId, thoughtEvent.content ?? "", {
+    timestamp,
+    thought_message_id: thoughtMessageId,
+    delta: thoughtEvent.delta,
+    is_complete: isComplete
+  });
+  if (!isComplete) runtimeEvent.ephemeral = true;
+  const thoughtMeta = isRecord2(thoughtEvent.meta) ? thoughtEvent.meta : void 0;
+  if (context.metadata || thoughtMeta) {
+    runtimeEvent.metadata = { ...runtimeEvent.metadata ?? {}, ...context.metadata ?? {}, ...thoughtMeta ?? {} };
+  }
+  return runtimeEvent;
+}
+function mapToolProgressToRuntime(toolEvent, context, options, id, timestamp) {
+  const toolName = toolEvent.tool_name || "unknown_tool";
+  const toolCallId = toolEvent.tool_call_id || `call_${id}`;
+  const meta = toolEvent.meta && typeof toolEvent.meta === "object" ? { ...toolEvent.meta } : {};
+  const displayOptions = resolveToolDisplayOptions(toolName, options.toolPresentationPort);
+  if (displayOptions && !meta.displayOptions) meta.displayOptions = displayOptions;
+  const event = toolEvent.type === "tool_call_decision" ? createToolCallDecisionEvent(id, context.conversationId, context.turnId, toolName, toolCallId, {
+    timestamp,
+    phase: toolEvent.phase ?? "start",
+    status: toolEvent.status ?? "loading",
+    args: toolEvent.tool_args || {},
+    payload: toolEvent.payload || {},
+    meta
+  }) : createToolProcessEvent(id, context.conversationId, context.turnId, toolName, toolCallId, {
+    timestamp,
+    phase: toolEvent.phase ?? "start",
+    status: toolEvent.status ?? "loading",
+    args: toolEvent.tool_args || {},
+    payload: toolEvent.payload || {},
+    meta
+  });
+  event.ephemeral = meta.ephemeral === true;
+  if (context.metadata) event.metadata = { ...event.metadata ?? {}, ...context.metadata };
+  return event;
+}
+function mapStreamChunkToRuntime(streamEvent, context, id, timestamp) {
+  const text = streamEvent.content ?? "";
+  if (!text) return null;
+  const answerId = readAgentEventAnswerId(streamEvent) ?? `answer_${context.turnId}`;
+  const seq = readAgentEventSeq(streamEvent) ?? 0;
+  const isLast = Boolean(
+    "isLast" in streamEvent && streamEvent.isLast || "is_last" in streamEvent && streamEvent.is_last
+  );
+  const chunkEvent = createFinalAnswerChunkEvent(id, context.conversationId, context.turnId, answerId, seq, text, {
+    timestamp,
+    is_last: isLast
+  });
+  chunkEvent.ephemeral = true;
+  if (context.metadata) chunkEvent.metadata = { ...chunkEvent.metadata ?? {}, ...context.metadata };
+  return chunkEvent;
+}
+
+// src/runtime-kernel/events/runtime-to-ai-message.ts
+function applyRuntimeEventToMemory(event, memory) {
+  if (!event || !memory) return;
+  switch (event.type) {
+    case "user_input": {
+      const userEvent = event;
+      memory.addUserMessage(userEvent.content || "", userEvent.id);
+      break;
+    }
+    case "tool_call_decision":
+      applyToolCallDecision(event, memory);
+      break;
+    case "tool_output":
+      applyToolOutput(event, memory);
+      break;
+    case "final_answer": {
+      const answerEvent = event;
+      const answerContent = answerEvent.content || "";
+      if (answerContent.trim()) {
+        const metadata = Array.isArray(answerEvent.reasoning_details) ? { reasoning_details: answerEvent.reasoning_details } : void 0;
+        memory.addAssistantMessage(answerContent, "final_answer", metadata, answerEvent.id);
+      }
+      break;
+    }
+    case "thought": {
+      const thoughtEvent = event;
+      memory.addAssistantMessage(thoughtEvent.content || "", "thought", void 0, thoughtEvent.id);
+      break;
+    }
+    case "history_summary":
+      applyHistorySummary(event, memory);
+      break;
+  }
+}
+function applyToolCallDecision(event, memory) {
+  const payload = event.payload || {};
+  const toolCalls = Array.isArray(payload.tool_calls) ? payload.tool_calls.filter(isToolCallWire) : [];
+  const toolArgs = event.args || payload.args || {};
+  const toolCallId = event.tool_call_id || (toolCalls.length > 0 ? toolCalls[0].id : `call_${event.id || Date.now()}`);
+  const normalizedToolCalls = toolCalls.length > 0 ? toolCalls : [
+    {
+      id: toolCallId,
+      type: "function",
+      function: { name: event.tool_name, arguments: JSON.stringify(toolArgs || {}) }
+    }
+  ];
+  const reasoningDetails = Array.isArray(payload.reasoning_details) ? payload.reasoning_details : void 0;
+  memory.addAssistantMessage(
+    null,
+    "tool_calls",
+    {
+      tool_calls: normalizedToolCalls,
+      ...reasoningDetails ? { reasoning_details: reasoningDetails } : {}
+    },
+    event.id
+  );
+}
+function applyToolOutput(event, memory) {
+  if (!event.tool_call_id) return;
+  const payload = event.payload || {};
+  const outputValue = payload.result ?? payload.output ?? event.output;
+  let serializedOutput;
+  if (typeof outputValue === "string") {
+    serializedOutput = outputValue;
+  } else {
+    try {
+      serializedOutput = JSON.stringify(outputValue ?? "");
+    } catch {
+      serializedOutput = String(outputValue ?? "");
+    }
+  }
+  memory.addToolResponse(String(event.tool_call_id), serializedOutput, event.tool_name, event.id);
+}
+function applyHistorySummary(summaryEvent, memory) {
+  const summaryMetadata = {
+    messageType: "summary",
+    generatedBy: summaryEvent.generated_by || "AgentSummarizationProvider",
+    originalMessageCount: summaryEvent.original_message_count,
+    compressionRatio: summaryEvent.compression_ratio,
+    includedOldSummary: summaryEvent.included_old_summary,
+    replacesStartMessageId: summaryEvent.replaces_start_message_id,
+    replacesEndMessageId: summaryEvent.replaces_end_message_id,
+    replacedMessageIds: Array.isArray(summaryEvent.replaced_message_ids) ? summaryEvent.replaced_message_ids : [],
+    summarySeq: summaryEvent.summary_seq || 0
+  };
+  const summaryMessage = {
+    id: summaryEvent.id,
+    role: "system",
+    type: "history_summary",
+    content: summaryEvent.content || "",
+    timestamp: summaryEvent.timestamp,
+    metadata: summaryMetadata
+  };
+  memory.appendMessage(summaryMessage);
+}
+
+// src/runtime-kernel/events/sse-projection.ts
+function agentEventToSSE(agentEvent, context, options = {}) {
+  if (!agentEvent || typeof agentEvent !== "object") return null;
+  if (options.skipAlreadyDispatched && isMarkedAsSseDispatched(agentEvent)) return null;
+  const { conversationId, turnId } = context;
+  const timestamp = agentEvent.timestamp ?? context.timestamp ?? Date.now();
+  const id = agentEvent.id ?? generateMessageId();
+  const contextMeta = context.metadata;
+  switch (agentEvent.type) {
+    case "thought": {
+      const thoughtEvent = agentEvent;
+      const rawContent = "content" in thoughtEvent ? thoughtEvent.content : "";
+      const delta = "delta" in thoughtEvent ? thoughtEvent.delta : "";
+      const isComplete = "is_complete" in thoughtEvent ? Boolean(thoughtEvent.is_complete) : false;
+      const thoughtMessageId = typeof thoughtEvent.thought_message_id === "string" && thoughtEvent.thought_message_id.length > 0 ? thoughtEvent.thought_message_id : void 0;
+      const sse = createSSEThoughtEvent(id, conversationId, turnId, {
+        thought_message_id: thoughtMessageId,
+        content: isComplete ? rawContent ?? "" : void 0,
+        delta: !isComplete ? delta ?? rawContent : void 0,
+        is_complete: isComplete
+      });
+      sse.timestamp = timestamp;
+      const thoughtMeta = isRecord2(thoughtEvent.meta) ? thoughtEvent.meta : void 0;
+      if (contextMeta || thoughtMeta) {
+        sse.metadata = { ...contextMeta ?? {}, ...thoughtMeta ?? {} };
+      }
+      return sse;
+    }
+    case "tool_call_decision":
+    case "tool_process":
+      return mapToolProgressToSse(agentEvent, context, options, id, timestamp);
+    case "observation": {
+      const observationEvent = agentEvent;
+      const toolName = observationEvent.tool_name || "unknown_tool";
+      const toolCallId = observationEvent.tool_call_id || `call_${id}`;
+      const status = observationEvent.success === false ? "error" : "success";
+      const payload = observationEvent.payload || {};
+      const duration = payload.duration_ms;
+      const sse = createSSEToolOutputEvent(
+        id,
+        conversationId,
+        turnId,
+        toolName,
+        toolCallId,
+        status,
+        observationEvent.output,
+        { timestamp, payload, duration_ms: duration }
+      );
+      sse.timestamp = timestamp;
+      if (contextMeta) sse.metadata = contextMeta;
+      return sse;
+    }
+    case "stream_chunk": {
+      const streamEvent = agentEvent;
+      const text = streamEvent.content ?? "";
+      if (!text) return null;
+      const answerId = readAgentEventAnswerId(streamEvent) ?? `answer_${turnId}`;
+      const seq = readAgentEventSeq(streamEvent) ?? 0;
+      const isLast = Boolean(
+        "isLast" in streamEvent && streamEvent.isLast || "is_last" in streamEvent && streamEvent.is_last
+      );
+      const sse = createSSEFinalAnswerChunkEvent(id, conversationId, turnId, answerId, seq, text, {
+        is_last: isLast
+      });
+      sse.timestamp = timestamp;
+      if (contextMeta) sse.metadata = contextMeta;
+      return sse;
+    }
+    case "final_answer": {
+      const finalAnswerEvent = agentEvent;
+      const answer = finalAnswerEvent.answer ?? "";
+      const answerIdFromSnake = typeof finalAnswerEvent.answer_id === "string" && finalAnswerEvent.answer_id.trim().length > 0 ? finalAnswerEvent.answer_id.trim() : void 0;
+      const answerId = answerIdFromSnake ?? readAnswerIdFromEvent(finalAnswerEvent) ?? `answer_${turnId}`;
+      const sse = createSSEFinalAnswerEvent(id, conversationId, turnId, answerId, answer, {
+        meta: readMetaFromEvent(finalAnswerEvent)
+      });
+      sse.timestamp = timestamp;
+      if (contextMeta) sse.metadata = contextMeta;
+      return sse;
+    }
+    case "error": {
+      const errorEvent = agentEvent;
+      const sse = createSSEErrorEvent(id, conversationId, turnId, errorEvent.error ?? "Unknown error", {
+        details: errorEvent.details
+      });
+      sse.timestamp = timestamp;
+      if (contextMeta) sse.metadata = contextMeta;
+      return sse;
+    }
+    default:
+      return null;
+  }
+}
+function mapToolProgressToSse(agentEvent, context, options, id, timestamp) {
+  const toolName = agentEvent.tool_name || "unknown_tool";
+  const toolCallId = agentEvent.tool_call_id || `call_${id}`;
+  const phase = agentEvent.phase ?? "start";
+  const status = agentEvent.status ?? "loading";
+  const args = agentEvent.tool_args || {};
+  const payload = agentEvent.payload || {};
+  const meta = agentEvent.meta && typeof agentEvent.meta === "object" ? { ...agentEvent.meta } : {};
+  const displayOptions = resolveToolDisplayOptions(toolName, options.toolPresentationPort);
+  if (displayOptions && !meta.displayOptions) meta.displayOptions = displayOptions;
+  const sse = agentEvent.type === "tool_call_decision" ? createSSEToolCallDecisionEvent(id, context.conversationId, context.turnId, toolName, toolCallId, phase, status, {
+    timestamp,
+    args,
+    payload,
+    meta
+  }) : createSSEToolProcessEvent(id, context.conversationId, context.turnId, toolName, toolCallId, phase, status, {
+    timestamp,
+    args,
+    payload,
+    meta
+  });
+  sse.timestamp = timestamp;
+  if (context.metadata) sse.metadata = context.metadata;
+  return sse;
+}
+
+// src/runtime-kernel/events/eventMappers.ts
+var eventMapper = {
+  /**
+   * 将 AgentEvent 转换为 SSEEvent。
+   */
+  agentToSse: agentEventToSSE,
+  /**
+   * 将 AgentEvent 转换为 RuntimeEvent。
+   */
+  agentToRuntime: agentEventToRuntime,
+  /**
+   * 将 RuntimeEvent 应用到 ConversationMemoryPort。
+   */
+  applyToMemory: applyRuntimeEventToMemory,
+  /**
+   * 批量处理 AgentEvent → SSEEvent + RuntimeEvent。
+   */
+  agentToBoth: (agentEvent, context, options = {}) => {
+    const sseEvent = agentEventToSSE(agentEvent, context, options.sseOptions);
+    const runtimeEvent = agentEventToRuntime(agentEvent, context, options.runtimeOptions);
+    return { sseEvent, runtimeEvent };
+  },
+  /**
+   * 批量重建内存。
+   */
+  rebuildMemory: (events, memory) => {
+    for (const event of events) {
+      applyRuntimeEventToMemory(event, memory);
+    }
+  }
+};
+
+// src/runtime-kernel/events/eventGovernance.ts
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isToolCallDecisionEvent(event) {
+  return event.type === "tool_call_decision";
+}
+function isToolProcessEvent(event) {
+  return event.type === "tool_process";
+}
+function isTodoUpdatedRuntimeEvent(event) {
+  return event.type === "todo_updated";
+}
+function isSubRunTraceRuntimeEvent(event) {
+  return event.type === "subrun_trace";
+}
+function isStreamEndRuntimeEvent(event) {
+  return event.type === "stream_end";
+}
+function isRequiresUserInteractionRuntimeEvent(event) {
+  return event.type === "requires_user_interaction";
+}
+function isAuditEnvelopeRuntimeEvent(event) {
+  return event.type === "audit_envelope";
+}
+function isControlRuntimeEvent(event) {
+  return event.type === "control";
+}
+function isHiddenUserInputEvent(event) {
+  if (event.type !== "user_input") {
+    return false;
+  }
+  const metadata = isRecord3(event.metadata) ? event.metadata : void 0;
+  const ui = metadata && isRecord3(metadata.ui) ? metadata.ui : void 0;
+  return ui?.presentation === "hidden";
+}
+function isEmptyTerminalAssistantRuntimeEvent(event) {
+  if (event.type !== "thought" && event.type !== "final_answer") {
+    return false;
+  }
+  return event.content.trim().length === 0;
+}
+function shouldPersistRuntimeEvent(event) {
+  return describeRuntimeEventLifecycle(event).persist;
+}
+function shouldReplayRuntimeEventToUi(event) {
+  return describeRuntimeEventLifecycle(event).replayToUi;
+}
+function shouldEnterAgentContext(event) {
+  return describeRuntimeEventLifecycle(event).enterAgentContext;
+}
+function isCheckpointHistorySummaryEvent(event) {
+  if (event.type !== "history_summary") {
+    return false;
+  }
+  const metadata = isRecord3(event.metadata) ? event.metadata : void 0;
+  return metadata?.summary_kind === "checkpoint";
+}
+function getRuntimeEventUiProjectionKind(event) {
+  if (isHiddenUserInputEvent(event)) {
+    return "hidden";
+  }
+  switch (event.type) {
+    case "user_input":
+      return "user_input";
+    case "thought":
+      return "thought";
+    case "final_answer":
+      return "final_answer";
+    case "final_answer_chunk":
+      return "final_answer_chunk";
+    case "tool_call_decision":
+      return "tool_call_decision";
+    case "tool_process":
+      return "tool_process";
+    case "tool_output":
+      return "tool_output";
+    case "requires_user_interaction":
+      return "requires_user_interaction";
+    case "audit_envelope":
+      return "audit_envelope";
+    case "todo_updated":
+      return "todo_updated";
+    case "subrun_trace":
+      return "subrun_trace";
+    case "error":
+      return "error";
+    case "stream_end":
+      return "stream_end";
+    case "history_summary":
+      return isCheckpointHistorySummaryEvent(event) ? "checkpoint_history_summary" : "history_summary";
+    default:
+      return "unsupported";
+  }
+}
+function describeRuntimeEventLifecycle(event) {
+  const uiProjectionKind = getRuntimeEventUiProjectionKind(event);
+  const persist = event.ephemeral !== true && !isToolProcessEvent(event);
+  const replayToUi = uiProjectionKind !== "hidden" && uiProjectionKind !== "audit_envelope" && uiProjectionKind !== "final_answer_chunk" && uiProjectionKind !== "unsupported";
+  const enterAgentContext = (() => {
+    if (isTodoUpdatedRuntimeEvent(event)) {
+      return false;
+    }
+    if (isSubRunTraceRuntimeEvent(event)) {
+      return false;
+    }
+    if (isStreamEndRuntimeEvent(event)) {
+      return false;
+    }
+    if (isRequiresUserInteractionRuntimeEvent(event)) {
+      return false;
+    }
+    if (isAuditEnvelopeRuntimeEvent(event)) {
+      return false;
+    }
+    if (isControlRuntimeEvent(event)) {
+      return false;
+    }
+    if (isHiddenUserInputEvent(event)) {
+      return false;
+    }
+    if (isToolProcessEvent(event)) {
+      return false;
+    }
+    if (event.type === "final_answer_chunk") {
+      return false;
+    }
+    if (isEmptyTerminalAssistantRuntimeEvent(event)) {
+      return false;
+    }
+    return true;
+  })();
+  const realtimeChannel = (() => {
+    switch (uiProjectionKind) {
+      case "thought":
+      case "final_answer":
+      case "final_answer_chunk":
+      case "tool_call_decision":
+      case "tool_process":
+      case "tool_output":
+      case "requires_user_interaction":
+      case "todo_updated":
+      case "subrun_trace":
+      case "error":
+        return "event_bus_sse";
+      case "audit_envelope":
+        return "none";
+      default:
+        return "none";
+    }
+  })();
+  return {
+    uiProjectionKind,
+    persist,
+    replayToUi,
+    enterAgentContext,
+    realtimeChannel
+  };
+}
+function shouldEmitRuntimeEventToSse(event) {
+  return describeRuntimeEventLifecycle(event).realtimeChannel === "event_bus_sse";
+}
+
+exports.describeRuntimeEventLifecycle = describeRuntimeEventLifecycle;
+exports.eventMapper = eventMapper;
+exports.getRuntimeEventUiProjectionKind = getRuntimeEventUiProjectionKind;
+exports.isCheckpointHistorySummaryEvent = isCheckpointHistorySummaryEvent;
+exports.isToolCallDecisionEvent = isToolCallDecisionEvent;
+exports.shouldEmitRuntimeEventToSse = shouldEmitRuntimeEventToSse;
+exports.shouldEnterAgentContext = shouldEnterAgentContext;
+exports.shouldPersistRuntimeEvent = shouldPersistRuntimeEvent;
+exports.shouldReplayRuntimeEventToUi = shouldReplayRuntimeEventToUi;
+//# sourceMappingURL=events.cjs.map
+//# sourceMappingURL=events.cjs.map