stitchkit 0.77.0 → 0.79.0

package/dist/{index-m668wzyc.js → index-9s6z8vgf.js}

@@ -10,33 +10,30 @@ import {
   createBoundedSinkManager
 } from "./index-a59da114.js";
 import {
-  isAgentToolError
-} from "./index-3xnq72rz.js";
-import {
-  ToolExecutionControlError,
-  isToolExecutionControlError
-} from "./index-s4c8wy8m.js";
+  AgentRuntimeEventSchema,
+  agentDurableEventId
+} from "./index-85vfqd7m.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,
   AgentMessagePartSchema,
   AgentMessageSchema,
   AgentProvenanceSchema,
-  AgentProviderEnvelopeSchema,
-  AgentRecordIdSchema,
-  AgentRecordVersionSchema,
-  AgentRunMetricsSchema,
   AgentRunSchema,
-  AgentRunStateSchema,
   AgentSnapshotSchema,
-  AgentTerminalReasonSchema,
-  AgentTimestampSchema,
   runStateForTerminalReason
 } from "./index-x1th9s8c.js";
+import {
+  isAgentToolError
+} from "./index-3xnq72rz.js";
+import {
+  ToolExecutionControlError,
+  isToolExecutionControlError
+} from "./index-758zx2ha.js";
 import {
   isRecord,
   transportResult
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/agent-runtime/context-refusal.ts
 class AgentContextOverflowError extends Error {
@@ -189,127 +186,6 @@ function createAgentSessionCoordinator() {
   };
 }
 
-// src/agent-runtime/event-schema.ts
-import { z } from "zod";
-var AgentAdmissionEventSchema = z.object({
-  type: z.literal("admission"),
-  eventId: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  input: AgentMessageSchema,
-  run: AgentRunSchema,
-  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
-  emittedAt: AgentTimestampSchema
-});
-var EventIdentitySchema = z.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  emittedAt: AgentTimestampSchema
-});
-var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z.literal("assistant-delta"),
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  textDelta: z.string()
-});
-var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-start")
-});
-var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-delta"),
-  textDelta: z.string()
-});
-var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-end")
-});
-var AgentCheckpointEventSchema = EventIdentitySchema.extend({
-  type: z.literal("assistant-checkpoint"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRunStateEventSchema = EventIdentitySchema.extend({
-  type: z.literal("run-state"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  state: AgentRunStateSchema
-});
-var AgentToolStatusEventSchema = EventIdentitySchema.extend({
-  type: z.literal("tool-status"),
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  callId: AgentRecordIdSchema,
-  toolName: z.string().min(1),
-  status: z.enum(["started", "completed", "failed", "interrupted"]),
-  input: z.json().optional(),
-  output: z.json().optional()
-});
-var AgentTerminalEventSchema = EventIdentitySchema.extend({
-  type: z.literal("terminal"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  reason: AgentTerminalReasonSchema,
-  policyName: z.string().min(1).optional(),
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
-  AgentAdmissionEventSchema,
-  AgentTransientDeltaEventSchema,
-  AgentReasoningStartEventSchema,
-  AgentReasoningDeltaEventSchema,
-  AgentReasoningEndEventSchema,
-  AgentCheckpointEventSchema,
-  AgentRunStateEventSchema,
-  AgentToolStatusEventSchema,
-  AgentTerminalEventSchema
-]);
-var AgentRuntimeEventCursorSchema = z.object({
-  snapshotVersion: AgentRecordVersionSchema.optional(),
-  durableEventIds: z.array(AgentRecordIdSchema).optional(),
-  runtimeEpoch: z.string().min(1).optional(),
-  sequence: z.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/events.ts
 function createAgentRuntimeEventSink(config) {
   const manager = createBoundedSinkManager({
@@ -625,9 +501,9 @@ function createAgentToolFenceLifecycle(config) {
 }
 
 // src/agent-runtime/prompt.ts
-import { z as z2 } from "zod";
-var AgentTokenCountSchema = z2.object({
-  value: z2.int().nonnegative().optional(),
+import { z } from "zod";
+var AgentTokenCountSchema = z.object({
+  value: z.int().nonnegative().optional(),
   provenance: AgentProvenanceSchema.extract([
     "measured",
     "computed",
@@ -1058,7 +934,7 @@ function repairedSearchCall(toolCall, searchName) {
 }
 
 // src/agent-runtime/runtime-internals.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -1066,7 +942,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z3.json().safeParse(value);
+  const parsed = z2.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -2567,4 +2443,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, AgentAdmissionEventSchema, AgentTransientDeltaEventSchema, AgentReasoningStartEventSchema, AgentReasoningDeltaEventSchema, AgentReasoningEndEventSchema, AgentCheckpointEventSchema, AgentRunStateEventSchema, AgentToolStatusEventSchema, AgentTerminalEventSchema, AgentRuntimeEventSchema, AgentRuntimeEventCursorSchema, advanceAgentRuntimeEventCursor, agentDurableEventId, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentRuntimeConflictError, createAgentRuntime };
+export { AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentRuntimeConflictError, createAgentRuntime };

package/dist/{index-bfcpjw20.js → index-actkayzn.js}

@@ -14,7 +14,11 @@ import { basename, dirname, resolve } from "node:path";
 var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
 var DEFAULT_INSPECTION_BYTES = 64 * 1024;
 var DEFAULT_INSPECTION_TIMEOUT_MS = 15000;
-var NOFOLLOW_FLAG = constants.O_NOFOLLOW ?? 0;
+var nofollowFlag;
+var noFollow = () => {
+  nofollowFlag ??= constants.O_NOFOLLOW ?? 0;
+  return nofollowFlag;
+};
 var ManagedFileInspectionSchema = ManagedFileRefSchema.pick({
   mediaType: true,
   name: true
@@ -273,7 +277,7 @@ async function createManagedFileBoundary(config) {
       const maxBytes = positiveLimit(options.maxBytes, maxReadBytes, "maxBytes");
       let handle;
       try {
-        handle = await open(realTarget, constants.O_RDONLY | NOFOLLOW_FLAG);
+        handle = await open(realTarget, constants.O_RDONLY | noFollow());
         const info = await handle.stat();
         if (!info.isFile()) {
           throw new ManagedFileError("FILE_NOT_REGULAR", "managed path is not a regular file");
@@ -310,7 +314,7 @@ async function createManagedFileBoundary(config) {
       let committed = false;
       let size = 0;
       try {
-        handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | NOFOLLOW_FLAG, 384);
+        handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | noFollow(), 384);
         const written = await writeSource(handle, source, maxBytes, inspectionBytes, options.signal);
         size = written.size;
         if (options.durable)

package/dist/index-b9aefrqd.js

@@ -0,0 +1,20 @@
+// src/internal/deadline.ts
+async function withDeadline(value, timeoutMs) {
+  if (!(value instanceof Promise))
+    return { settled: true, value };
+  let timer;
+  const expiry = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ settled: false }), timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      value.then((settledValue) => ({ settled: true, value: settledValue })),
+      expiry
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+
+export { withDeadline };

package/dist/index-dre2ywck.js

@@ -0,0 +1,48 @@
+import {
+  LiveStatePhaseSchema,
+  LiveStateStopReasonSchema
+} from "./index-ywd0y6m1.js";
+
+// src/live/watch-contract.ts
+import { z } from "zod";
+var WatchKeySchema = z.object({
+  service: z.string().min(1),
+  action: z.string().min(1),
+  digest: z.string().min(1)
+}).strict().readonly();
+var WatchOpenSchema = z.object({ key: WatchKeySchema, args: z.unknown() }).readonly();
+var WatchAcceptedSchema = z.object({
+  accepted: z.boolean(),
+  reason: z.string().optional()
+}).strict().readonly();
+var WatchValueSchema = z.object({
+  key: WatchKeySchema,
+  revision: z.number().int().nonnegative(),
+  value: z.unknown()
+}).readonly();
+var WatchStateSchema = z.object({
+  key: WatchKeySchema,
+  phase: LiveStatePhaseSchema,
+  reason: LiveStateStopReasonSchema.optional(),
+  code: z.string().optional(),
+  message: z.string().optional()
+}).readonly();
+var WATCH_OPEN = "stitchkit.watch.open";
+var WATCH_CLOSE = "stitchkit.watch.close";
+var WATCH_VALUE = "stitchkit.watch.value";
+var WATCH_STATE = "stitchkit.watch.state";
+var watchContract = {
+  serverToClient: {
+    [WATCH_VALUE]: { args: z.tuple([WatchValueSchema]) },
+    [WATCH_STATE]: { args: z.tuple([WatchStateSchema]) }
+  },
+  clientToServer: {
+    [WATCH_OPEN]: { args: z.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
+    [WATCH_CLOSE]: { args: z.tuple([z.object({ key: WatchKeySchema }).readonly()]) }
+  }
+};
+function watchKeyString(key) {
+  return `${key.service}/${key.action}/${key.digest}`;
+}
+
+export { WatchKeySchema, WatchValueSchema, WatchStateSchema, WATCH_OPEN, WATCH_CLOSE, WATCH_VALUE, WATCH_STATE, watchContract, watchKeyString };

package/dist/{index-nemjkxjp.js → index-dwf1f2ap.js}

@@ -1,12 +1,12 @@
 import {
   resolveTraceContext
-} from "./index-nt1mp8km.js";
+} from "./index-fxz0v7vg.js";
 import {
   isUnsafeKey
-} from "./index-vj3vvpaa.js";
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/server/request.ts
 function generateTraceId() {
@@ -179,38 +179,42 @@ function isPublicIp(value) {
 
 // src/observability/context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
+var storage;
+var requestStorage = () => {
+  storage ??= new AsyncLocalStorage;
+  return storage;
+};
 function runWithRequestContext(ctx, fn) {
-  return storage.run(ctx, fn);
+  return requestStorage().run(ctx, fn);
 }
 function getRequestContext() {
-  return storage.getStore();
+  return requestStorage().getStore();
 }
 function getTraceId() {
-  return storage.getStore()?.trace.traceId;
+  return requestStorage().getStore()?.trace.traceId;
 }
 function getUserId() {
-  return storage.getStore()?.userId;
+  return requestStorage().getStore()?.userId;
 }
 function setRequestUser(userId) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx)
     ctx.userId = userId;
 }
 function setRequestEndpoint(serviceName, action) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx) {
     ctx.serviceName = serviceName;
     ctx.action = action;
   }
 }
 function setRequestDimensions(dimensions) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx)
     ctx.dimensions = { ...ctx.dimensions, ...dimensions };
 }
 function setRequestError(error) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx)
     ctx.error = error;
 }

package/dist/{index-wwst0td5.js → index-dx9xehwt.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {

package/dist/{index-ezmn6ac6.js → index-dxesg10d.js}

@@ -3,18 +3,18 @@ import {
 } from "./index-3xnq72rz.js";
 import {
   collectToolSurface
-} from "./index-k2zczx1g.js";
+} from "./index-2rwwmr7v.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-7qy2ex0m.js";
+} from "./index-5mtc969c.js";
 import {
   isToolExecutionControlError,
   toolResultFromError
-} from "./index-s4c8wy8m.js";
+} from "./index-758zx2ha.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/tools/agent.ts
 import { jsonSchema, tool } from "ai";

package/dist/{index-aczggrty.js → index-dxjjv399.js}

@@ -1,9 +1,9 @@
 import {
   isUnsafeKey
-} from "./index-vj3vvpaa.js";
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/observability/sanitize.ts
 var SENSITIVE_WORDS = new Set([

package/dist/{index-jqtsc9mj.js → index-egaabxkz.js}

@@ -1,13 +1,13 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-7qy2ex0m.js";
+} from "./index-5mtc969c.js";
 import {
   toolErrorFromResult
-} from "./index-s4c8wy8m.js";
+} from "./index-758zx2ha.js";
 import {
   assertUniqueToolName
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 import {
   AppError
 } from "./index-0w9abg87.js";

package/dist/{index-vc1b0b1b.js → index-evcnmsc3.js}

@@ -5,7 +5,7 @@ import {
   ApplicationIdSchema,
   ApplicationShutdownResultSchema,
   ApplicationSnapshotSchema
-} from "./index-8eywc9zv.js";
+} from "./index-3gye9wzb.js";
 import {
   ShutdownOptionsSchema
 } from "./index-3z73fh2c.js";
@@ -85,7 +85,11 @@ var ApplicationShutdownBudgetSchema = ShutdownOptionsSchema.pick({
   gracePeriodMs: true,
   forceTimeoutMs: true
 });
-var ApplicationRestartInputSchema = z.object({ resourceId: z.string().min(1) }).strict().readonly();
+var ApplicationRestartInputSchema = z.object({
+  resourceId: z.string().min(1),
+  gracePeriodMs: z.number().int().nonnegative().optional(),
+  forceTimeoutMs: z.number().int().nonnegative().optional()
+}).strict().readonly();
 var ApplicationRestartOutcomeSchema = z.enum(["restarted", "failed", "refused"]);
 var ApplicationRestartResultSchema = z.object({
   resourceId: z.string(),
@@ -177,6 +181,7 @@ function createApplication(config) {
     return optionalUnhealthy ? "degraded" : "healthy";
   };
   const isReady = () => lifecycle === "ready" && [...records.values()].every((record) => !record.entry.required || record.state === "ready" && record.health === "healthy");
+  let restartingIds = [];
   const snapshot = () => ApplicationSnapshotSchema.parse({
     id,
     epoch,
@@ -187,6 +192,7 @@ function createApplication(config) {
     capturedAt: new Date().toISOString(),
     changedAt,
     admission: { accepting, accepted, completed, pending },
+    restarting: [...restartingIds],
     resources: ordered.map((entry) => {
       const record = records.get(entry.id);
       if (!record)
@@ -444,13 +450,21 @@ function createApplication(config) {
     }
     return ordered.filter((entry) => affected.has(entry.id));
   };
-  const closeOne = async (entry, record, signal) => {
-    const context = () => contextFor(record, { signal });
+  const closeOne = async (entry, record, signal, deadlines) => {
+    const context = () => contextFor(record, { ...deadlines, signal });
     if (record.attempted && !record.closed) {
-      await entry.resource.stopAdmission?.(context());
-      await entry.resource.drain?.(context());
+      const phase = async (work, what) => {
+        const settled = await untilDeadline(Promise.resolve(work), signal);
+        if (!settled.settled) {
+          throw new Error(`[stitchkit] resource "${entry.id}" did not ${what} within the restart budget`);
+        }
+        if (settled.error !== undefined)
+          throw settled.error;
+      };
+      await phase(entry.resource.stopAdmission?.(context()), "stop admitting");
+      await phase(entry.resource.drain?.(context()), "drain");
       record.closeInvoked = true;
-      await entry.resource.close?.(context());
+      await phase(entry.resource.close?.(context()), "close");
     }
     record.closed = false;
     record.closeInvoked = false;
@@ -484,17 +498,39 @@ function createApplication(config) {
     if (lifecycle !== "ready") {
       return refuse(`the application is ${lifecycle}, not ready`);
     }
+    const budget = {
+      gracePeriodMs: parsed.gracePeriodMs ?? shutdownBudget.gracePeriodMs,
+      forceTimeoutMs: parsed.forceTimeoutMs ?? shutdownBudget.forceTimeoutMs
+    };
+    const closeDeadlineAt = performance.now() + budget.gracePeriodMs;
+    const deadlines = {
+      deadlineAt: closeDeadlineAt,
+      forceDeadlineAt: closeDeadlineAt + budget.forceTimeoutMs
+    };
+    restartingIds = affectedIds;
     const restartAbort = new AbortController;
+    const closeTimer = setTimeout(() => restartAbort.abort(), Math.max(0, deadlines.forceDeadlineAt - performance.now()));
+    const stillFailed = () => affectedIds.filter((id2) => records.get(id2)?.state === "failed");
     try {
       for (const entry of [...affected].reverse()) {
         const record = records.get(entry.id);
         if (record)
-          await closeOne(entry, record, restartAbort.signal);
+          await closeOne(entry, record, restartAbort.signal, deadlines);
       }
       publish();
       await startEach(affected, restartAbort.signal);
       await activateEach(affected, restartAbort.signal);
       publish();
+      const failed = stillFailed();
+      if (failed.length > 0) {
+        return {
+          resourceId: parsed.resourceId,
+          affected: affectedIds,
+          outcome: "failed",
+          reason: `did not come back: ${failed.join(", ")}`,
+          durationMs: Date.now() - startedAt
+        };
+      }
       return {
         resourceId: parsed.resourceId,
         affected: affectedIds,
@@ -502,6 +538,7 @@ function createApplication(config) {
         durationMs: Date.now() - startedAt
       };
     } catch (error) {
+      restartAbort.abort();
       publish();
       return {
         resourceId: parsed.resourceId,
@@ -510,6 +547,10 @@ function createApplication(config) {
         reason: error instanceof Error ? error.message : String(error),
         durationMs: Date.now() - startedAt
       };
+    } finally {
+      restartingIds = [];
+      clearTimeout(closeTimer);
+      publish();
     }
   };
   const runStart = async () => {