stitchkit 0.78.0 → 0.79.0

package/dist/agent-runtime-browser.js

@@ -1,589 +1,61 @@
-// src/agent-runtime/control-schema.ts
-import { z as z3 } from "zod";
-
-// src/agent-runtime/event-schema.ts
-import { z as z2 } from "zod";
-
-// src/agent-runtime/schemas.ts
-import { z } from "zod";
-var AgentRecordIdSchema = z.string().min(1);
-var AgentRecordVersionSchema = z.int().nonnegative();
-var AgentTimestampSchema = z.iso.datetime({ offset: true });
-var AgentJsonObjectSchema = z.record(z.string(), z.json());
-var AgentProviderEnvelopeSchema = z.object({
-  schemaVersion: z.int().positive(),
-  provider: z.string().min(1),
-  data: AgentJsonObjectSchema
-});
-var AgentTextPartSchema = z.object({
-  type: z.literal("text"),
-  text: z.string()
-});
-var AgentReasoningPartSchema = z.object({
-  type: z.literal("reasoning"),
-  text: z.string(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentFilePartSchema = z.object({
-  type: z.literal("file"),
-  mediaType: z.string().min(1),
-  reference: z.string().min(1),
-  filename: z.string().min(1).optional()
-});
-var AgentSourcePartSchema = z.object({
-  type: z.literal("source"),
-  sourceId: z.string().min(1),
-  url: z.url().optional(),
-  title: z.string().optional()
-});
-var AgentToolCallPartSchema = z.object({
-  type: z.literal("tool-call"),
-  callId: z.string().min(1),
-  toolName: z.string().min(1),
-  input: z.json(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentToolResultPartSchema = z.object({
-  type: z.literal("tool-result"),
-  callId: z.string().min(1),
-  toolName: z.string().min(1),
-  outcome: z.enum(["success", "error", "interrupted"]),
-  output: z.json().optional()
-});
-var AgentToolApprovalRequestPartSchema = z.object({
-  type: z.literal("tool-approval-request"),
-  approvalId: z.string().min(1),
-  callId: z.string().min(1),
-  isAutomatic: z.boolean().optional(),
-  signature: z.string().min(1).optional()
-});
-var AgentToolApprovalResponsePartSchema = z.object({
-  type: z.literal("tool-approval-response"),
-  approvalId: z.string().min(1),
-  approved: z.boolean(),
-  reason: z.string().min(1).optional()
-});
-var AgentOpaquePartSchema = z.object({
-  type: z.literal("provider"),
-  envelope: AgentProviderEnvelopeSchema
-});
-var AgentControlPartSchema = z.object({
-  type: z.literal("control"),
-  reason: z.enum(["run-interrupted", "stale-run"])
-});
-var AgentMessagePartSchema = z.discriminatedUnion("type", [
-  AgentTextPartSchema,
-  AgentReasoningPartSchema,
-  AgentFilePartSchema,
-  AgentSourcePartSchema,
-  AgentToolCallPartSchema,
-  AgentToolResultPartSchema,
-  AgentToolApprovalRequestPartSchema,
-  AgentToolApprovalResponsePartSchema,
-  AgentOpaquePartSchema,
-  AgentControlPartSchema
-]);
-var AgentMessageRoleSchema = z.enum([
-  "user",
-  "assistant",
-  "tool",
-  "system",
-  "summary"
-]);
-var AgentMessageStatusSchema = z.enum([
-  "committed",
-  "streaming",
-  "completed",
-  "interrupted",
-  "superseded",
-  "failed"
-]);
-var AgentMessageSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema.optional(),
-  role: AgentMessageRoleSchema,
-  status: AgentMessageStatusSchema,
-  parts: z.array(AgentMessagePartSchema),
-  metadata: AgentJsonObjectSchema.optional(),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
-});
-var AgentAssistantPlaceholderSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  status: z.literal("pending"),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
-});
-var AgentRunStateSchema = z.enum([
-  "queued",
-  "running",
-  "interrupt_requested",
-  "completed",
-  "interrupted",
-  "superseded",
-  "failed",
-  "cancelled",
-  "abandoned"
-]);
-var AgentRunQueuePrioritySchema = z.enum(["interrupt-next"]);
-var AgentTerminalReasonSchema = z.enum([
-  "success",
-  "policy_stop",
-  "provider_stop",
-  "interrupted",
-  "superseded",
-  "cancelled",
-  "timeout",
-  "shutdown",
-  "provider_failure",
-  "context_overflow",
-  "absorbed",
-  "abandoned"
-]);
-function runStateForTerminalReason(reason) {
-  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
-    return "completed";
-  }
-  if (reason === "interrupted")
-    return "interrupted";
-  if (reason === "superseded" || reason === "absorbed")
-    return "superseded";
-  if (reason === "cancelled" || reason === "shutdown" || reason === "timeout") {
-    return "cancelled";
-  }
-  if (reason === "abandoned")
-    return "abandoned";
-  return "failed";
-}
-var AgentProvenanceSchema = z.enum([
-  "provider-reported",
-  "measured",
-  "computed",
-  "estimated",
-  "unavailable"
-]);
-var AgentUsageValueSchema = z.object({
-  value: z.int().nonnegative().optional(),
-  provenance: AgentProvenanceSchema.extract([
-    "provider-reported",
-    "computed",
-    "estimated",
-    "unavailable"
-  ])
-});
-var AgentCostValueSchema = z.object({
-  value: z.number().nonnegative().optional(),
-  currency: z.string().length(3).optional(),
-  provenance: AgentProvenanceSchema.extract([
-    "provider-reported",
-    "computed",
-    "estimated",
-    "unavailable"
-  ])
-});
-var AgentUsageSchema = z.object({
-  inputTokens: AgentUsageValueSchema,
-  outputTokens: AgentUsageValueSchema,
-  reasoningTokens: AgentUsageValueSchema.optional(),
-  cacheReadTokens: AgentUsageValueSchema.optional(),
-  cacheWriteTokens: AgentUsageValueSchema.optional(),
-  cost: AgentCostValueSchema.optional()
-});
-var AgentRunFieldsSchema = z.object({
-  schemaVersion: z.literal(1),
-  id: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  inputMessageIds: z.array(AgentRecordIdSchema).min(1),
-  assistantMessageId: AgentRecordIdSchema,
-  state: AgentRunStateSchema,
-  revision: AgentRecordVersionSchema,
-  queuePriority: AgentRunQueuePrioritySchema.optional(),
-  executionSequence: AgentRecordVersionSchema.optional(),
-  ownerId: z.string().min(1).optional(),
-  fencingToken: AgentRecordVersionSchema.optional(),
-  terminalReason: AgentTerminalReasonSchema.optional(),
-  terminalPolicyName: z.string().min(1).optional(),
-  absorbedIntoRunId: AgentRecordIdSchema.optional(),
-  usage: AgentUsageSchema.optional(),
-  createdAt: AgentTimestampSchema,
-  updatedAt: AgentTimestampSchema
-});
-var AgentRunSchema = AgentRunFieldsSchema.superRefine((run, ctx) => {
-  if (run.terminalReason !== "absorbed" && run.absorbedIntoRunId !== undefined) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["absorbedIntoRunId"],
-      message: "Only an absorbed run names the run that answered it"
-    });
-  }
-  if (run.terminalReason === undefined) {
-    if (TERMINAL_RUN_STATES.has(run.state)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["terminalReason"],
-        message: `A run in terminal state "${run.state}" must say why it ended`
-      });
-    }
-    return;
-  }
-  const expected = runStateForTerminalReason(run.terminalReason);
-  if (run.state !== expected) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["state"],
-      message: `Terminal reason "${run.terminalReason}" ends a run in state "${expected}", not "${run.state}"`
-    });
-  }
-  if (run.terminalReason === "policy_stop" && run.terminalPolicyName === undefined) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["terminalPolicyName"],
-      message: "A policy stop names the policy that stopped the run"
-    });
-  }
-  if (run.terminalReason === "absorbed" && run.absorbedIntoRunId === undefined) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["absorbedIntoRunId"],
-      message: "An absorbed run names the run that answered its input"
-    });
-  }
-  if (run.absorbedIntoRunId === run.id) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["absorbedIntoRunId"],
-      message: "A run cannot absorb itself"
-    });
-  }
-});
-var TERMINAL_RUN_STATES = new Set([
-  "completed",
-  "interrupted",
-  "superseded",
-  "cancelled",
-  "abandoned",
-  "failed"
-]);
-var AgentSnapshotSchema = z.object({
-  schemaVersion: z.literal(1),
-  conversationId: AgentRecordIdSchema,
-  version: AgentRecordVersionSchema,
-  messages: z.array(AgentMessageSchema),
-  runs: z.array(AgentRunSchema)
-});
-var AgentRunMetricsSchema = z.object({
-  partial: z.boolean(),
-  usage: AgentUsageSchema,
-  durationMs: z.number().nonnegative().optional(),
-  ttftMs: z.number().nonnegative().optional()
-});
-
-// src/agent-runtime/event-schema.ts
-var AgentAdmissionEventSchema = z2.object({
-  type: z2.literal("admission"),
-  eventId: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  input: AgentMessageSchema,
-  run: AgentRunSchema,
-  assistant: z2.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
-  emittedAt: AgentTimestampSchema
-});
-var EventIdentitySchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  emittedAt: AgentTimestampSchema
-});
-var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-delta"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  textDelta: z2.string()
-});
-var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-start")
-});
-var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-delta"),
-  textDelta: z2.string()
-});
-var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z2.literal("reasoning-end")
-});
-var AgentCheckpointEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("assistant-checkpoint"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRunStateEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("run-state"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  state: AgentRunStateSchema
-});
-var AgentToolStatusEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("tool-status"),
-  runtimeEpoch: z2.string().min(1),
-  sequence: z2.int().nonnegative(),
-  callId: AgentRecordIdSchema,
-  toolName: z2.string().min(1),
-  status: z2.enum(["started", "completed", "failed", "interrupted"]),
-  input: z2.json().optional(),
-  output: z2.json().optional()
-});
-var AgentTerminalEventSchema = EventIdentitySchema.extend({
-  type: z2.literal("terminal"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  reason: AgentTerminalReasonSchema,
-  policyName: z2.string().min(1).optional(),
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRuntimeEventSchema = z2.discriminatedUnion("type", [
+import {
+  AgentControlDeliverySchema,
+  AgentControlRequestSchema,
+  AgentControlResponseSchema,
+  AgentMultiSessionCursorSchema,
+  advanceAgentMultiSessionCursor,
+  createAgentControlView,
+  reduceAgentControlEvent,
+  reduceAgentControlSnapshot
+} from "./index-5s3zajp8.js";
+import {
   AgentAdmissionEventSchema,
-  AgentTransientDeltaEventSchema,
-  AgentReasoningStartEventSchema,
+  AgentCheckpointEventSchema,
   AgentReasoningDeltaEventSchema,
   AgentReasoningEndEventSchema,
-  AgentCheckpointEventSchema,
+  AgentReasoningStartEventSchema,
   AgentRunStateEventSchema,
+  AgentRuntimeEventCursorSchema,
+  AgentRuntimeEventSchema,
+  AgentTerminalEventSchema,
   AgentToolStatusEventSchema,
-  AgentTerminalEventSchema
-]);
-var AgentRuntimeEventCursorSchema = z2.object({
-  snapshotVersion: AgentRecordVersionSchema.optional(),
-  durableEventIds: z2.array(AgentRecordIdSchema).optional(),
-  runtimeEpoch: z2.string().min(1).optional(),
-  sequence: z2.int().nonnegative().optional()
-});
-function isDurableEvent(event) {
-  return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
-}
-function advanceAgentRuntimeEventCursor(rawCursor, event) {
-  const cursor = AgentRuntimeEventCursorSchema.parse(rawCursor);
-  if (isDurableEvent(event)) {
-    const previous = cursor.snapshotVersion;
-    const durableEventIds = previous === event.snapshotVersion ? cursor.durableEventIds ?? [] : [];
-    if (previous !== undefined && event.snapshotVersion < previous || durableEventIds.includes(event.eventId)) {
-      return { status: "duplicate", cursor };
-    }
-    return {
-      status: "accepted",
-      cursor: {
-        ...cursor,
-        snapshotVersion: event.snapshotVersion,
-        durableEventIds: [...durableEventIds, event.eventId]
-      }
-    };
-  }
-  const previousSequence = cursor.runtimeEpoch === event.runtimeEpoch ? cursor.sequence : undefined;
-  if (previousSequence !== undefined && event.sequence <= previousSequence) {
-    return { status: "duplicate", cursor };
-  }
-  return {
-    status: previousSequence !== undefined && event.sequence > previousSequence + 1 ? "gap" : "accepted",
-    cursor: { ...cursor, runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
-  };
-}
-function agentDurableEventId(type, runId, snapshotVersion) {
-  return `${runId}:${type}:${snapshotVersion}`;
-}
-
-// src/agent-runtime/control-schema.ts
-var AgentControlIdentitySchema = z3.object({ schemaVersion: z3.literal(1), requestId: z3.string().min(1) }).strict();
-var AgentControlRequestSchema = z3.discriminatedUnion("operation", [
-  AgentControlIdentitySchema.extend({
-    operation: z3.literal("attach"),
-    conversationId: z3.string().min(1),
-    access: z3.enum(["observe", "control"])
-  }),
-  AgentControlIdentitySchema.extend({
-    operation: z3.literal("detach"),
-    conversationId: z3.string().min(1)
-  }),
-  AgentControlIdentitySchema.extend({
-    operation: z3.literal("snapshot"),
-    conversationId: z3.string().min(1)
-  }),
-  AgentControlIdentitySchema.extend({
-    operation: z3.literal("submit"),
-    conversationId: z3.string().min(1),
-    idempotencyKey: z3.string().min(1),
-    context: z3.unknown(),
-    parts: z3.array(AgentMessagePartSchema).min(1),
-    metadata: z3.unknown().optional()
-  }),
-  AgentControlIdentitySchema.extend({
-    operation: z3.literal("interrupt"),
-    conversationId: z3.string().min(1),
-    runId: z3.string().min(1)
-  }),
-  AgentControlIdentitySchema.extend({
-    operation: z3.literal("respond-approval"),
-    conversationId: z3.string().min(1),
-    approvalId: z3.string().min(1),
-    approved: z3.boolean(),
-    reason: z3.string().min(1).optional(),
-    context: z3.unknown(),
-    metadata: z3.unknown().optional()
-  })
-]);
-var AgentControlResponseIdentitySchema = z3.object({
-  schemaVersion: z3.literal(1),
-  requestId: z3.string().min(1)
-});
-var AgentControlResponseSchema = z3.discriminatedUnion("outcome", [
-  AgentControlResponseIdentitySchema.extend({
-    outcome: z3.literal("ok"),
-    snapshot: AgentSnapshotSchema.optional(),
-    runId: z3.string().min(1).optional()
-  }).strict(),
-  AgentControlResponseIdentitySchema.extend({
-    outcome: z3.literal("error"),
-    error: z3.object({ code: z3.string().min(1), message: z3.string().min(1) }).strict()
-  }).strict()
-]);
-var AgentControlDeliverySchema = z3.discriminatedUnion("type", [
-  z3.object({
-    schemaVersion: z3.literal(1),
-    type: z3.literal("event"),
-    event: AgentRuntimeEventSchema
-  }).strict(),
-  z3.object({
-    schemaVersion: z3.literal(1),
-    type: z3.literal("resync-required"),
-    conversationId: z3.string().min(1),
-    reason: z3.literal("overflow")
-  }).strict()
-]);
-var AgentMultiSessionCursorSchema = z3.object({
-  conversations: z3.record(z3.string(), z3.object({
-    snapshotVersion: z3.int().nonnegative().optional(),
-    durableEventIds: z3.array(z3.string().min(1)).optional(),
-    runs: z3.record(z3.string(), z3.object({ runtimeEpoch: z3.string().min(1), sequence: z3.int().nonnegative() }).strict())
-  }).strict())
-}).strict();
-function durable(event) {
-  return ["admission", "assistant-checkpoint", "run-state", "terminal"].includes(event.type);
-}
-function advanceAgentMultiSessionCursor(raw, event) {
-  const cursor = AgentMultiSessionCursorSchema.parse(raw);
-  const previous = cursor.conversations[event.conversationId] ?? { runs: {} };
-  if (durable(event)) {
-    const ids = previous.snapshotVersion === event.snapshotVersion ? previous.durableEventIds ?? [] : [];
-    if (previous.snapshotVersion !== undefined && event.snapshotVersion < previous.snapshotVersion || ids.includes(event.eventId)) {
-      return { status: "duplicate", cursor };
-    }
-    return {
-      status: "accepted",
-      cursor: {
-        conversations: {
-          ...cursor.conversations,
-          [event.conversationId]: {
-            ...previous,
-            snapshotVersion: event.snapshotVersion,
-            durableEventIds: [...ids, event.eventId]
-          }
-        }
-      }
-    };
-  }
-  const run = previous.runs[event.runId];
-  const sequence = run?.runtimeEpoch === event.runtimeEpoch ? run.sequence : undefined;
-  if (sequence !== undefined && event.sequence <= sequence)
-    return { status: "duplicate", cursor };
-  const expected = sequence === undefined ? 1 : sequence + 1;
-  return {
-    status: event.sequence === expected ? "accepted" : "gap",
-    cursor: {
-      conversations: {
-        ...cursor.conversations,
-        [event.conversationId]: {
-          ...previous,
-          runs: {
-            ...previous.runs,
-            [event.runId]: { runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
-          }
-        }
-      }
-    }
-  };
-}
-function createAgentControlView() {
-  return { cursor: { conversations: {} }, conversations: {} };
-}
-function reduceAgentControlSnapshot(view, rawSnapshot) {
-  const snapshot = AgentSnapshotSchema.parse(rawSnapshot);
-  const previous = view.cursor.conversations[snapshot.conversationId] ?? { runs: {} };
-  return {
-    cursor: {
-      conversations: {
-        ...view.cursor.conversations,
-        [snapshot.conversationId]: {
-          ...previous,
-          snapshotVersion: snapshot.version,
-          durableEventIds: []
-        }
-      }
-    },
-    conversations: {
-      ...view.conversations,
-      [snapshot.conversationId]: {
-        snapshot,
-        resyncRequired: false,
-        transientByRun: {}
-      }
-    }
-  };
-}
-function reduceAgentControlEvent(view, rawEvent) {
-  const event = AgentRuntimeEventSchema.parse(rawEvent);
-  const advanced = advanceAgentMultiSessionCursor(view.cursor, event);
-  if (advanced.status === "duplicate")
-    return view;
-  const current = view.conversations[event.conversationId] ?? {
-    resyncRequired: false,
-    transientByRun: {}
-  };
-  if (advanced.status === "gap") {
-    return {
-      cursor: advanced.cursor,
-      conversations: {
-        ...view.conversations,
-        [event.conversationId]: { ...current, resyncRequired: true }
-      }
-    };
-  }
-  const transient = current.transientByRun[event.runId] ?? { text: "", reasoning: "" };
-  const nextTransient = event.type === "assistant-delta" ? { ...transient, text: transient.text + event.textDelta } : event.type === "reasoning-delta" ? { ...transient, reasoning: transient.reasoning + event.textDelta } : transient;
-  const snapshotStale = durable(event) && current.snapshot?.version !== event.snapshotVersion;
-  const transientByRun = event.type === "terminal" ? Object.fromEntries(Object.entries(current.transientByRun).filter(([runId]) => runId !== event.runId)) : { ...current.transientByRun, [event.runId]: nextTransient };
-  return {
-    cursor: advanced.cursor,
-    conversations: {
-      ...view.conversations,
-      [event.conversationId]: {
-        ...current,
-        resyncRequired: current.resyncRequired || snapshotStale,
-        transientByRun
-      }
-    }
-  };
-}
+  AgentTransientDeltaEventSchema,
+  advanceAgentRuntimeEventCursor,
+  agentDurableEventId
+} from "./index-85vfqd7m.js";
+import {
+  AgentAssistantPlaceholderSchema,
+  AgentControlPartSchema,
+  AgentCostValueSchema,
+  AgentFilePartSchema,
+  AgentJsonObjectSchema,
+  AgentMessagePartSchema,
+  AgentMessageRoleSchema,
+  AgentMessageSchema,
+  AgentMessageStatusSchema,
+  AgentOpaquePartSchema,
+  AgentProvenanceSchema,
+  AgentProviderEnvelopeSchema,
+  AgentReasoningPartSchema,
+  AgentRecordIdSchema,
+  AgentRecordVersionSchema,
+  AgentRunMetricsSchema,
+  AgentRunQueuePrioritySchema,
+  AgentRunSchema,
+  AgentRunStateSchema,
+  AgentSnapshotSchema,
+  AgentSourcePartSchema,
+  AgentTerminalReasonSchema,
+  AgentTextPartSchema,
+  AgentTimestampSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
+  AgentToolCallPartSchema,
+  AgentToolResultPartSchema,
+  AgentUsageSchema,
+  AgentUsageValueSchema,
+  runStateForTerminalReason
+} from "./index-x1th9s8c.js";
 export {
   runStateForTerminalReason,
   reduceAgentControlSnapshot,

package/dist/agent-runtime-coding-tools.js

@@ -13,17 +13,18 @@ import {
 } from "./index-rqpdar1e.js";
 import {
   defineRuntimeTool
-} from "./index-wwst0td5.js";
-import"./index-22by16v6.js";
+} from "./index-dx9xehwt.js";
+import"./index-mgtxfe6b.js";
 import"./index-cby4ar3v.js";
-import"./index-vj3vvpaa.js";
-import"./index-qyrqwr4c.js";
+import"./index-y01f4223.js";
+import"./index-6k1937bx.js";
 import {
   AppError,
   conflict,
   forbidden
 } from "./index-0w9abg87.js";
-import"./index-6k1937bx.js";
+import"./index-kzfs85xp.js";
+import"./index-77fekveh.js";
 
 // src/agent-runtime/coding-tools.ts
 import path4 from "node:path";