stitchkit 0.70.0 → 0.70.2

package/dist/declaration.js

@@ -157,27 +157,27 @@ function findProjectRole(declaration, name) {
   return declaration.roles.find((role) => role.name === name);
 }
 export {
-  BindingVariableSchema,
-  PROJECT_DECLARATION_SCHEMA_VERSION,
-  ProjectBuildInputSchema,
-  ProjectBuildSchema,
-  ProjectCommandSchema,
-  ProjectDeclarationSchema,
-  ProjectDescriptionSchema,
-  ProjectEnvShapeSchema,
-  ProjectEnvVariableSchema,
-  ProjectIdentitySchema,
-  ProjectListenerSchema,
-  ProjectMigrationsSchema,
-  ProjectReleaseSchema,
-  ProjectRequirementPhaseSchema,
-  ProjectRequirementSchema,
-  ProjectRoleCommandSchema,
-  ProjectRoleSchema,
-  ProjectRunModeSchema,
-  ProjectSlugSchema,
-  RepositoryPathSchema,
-  findProjectRole,
+  parseProjectDeclaration,
   namesAMachine,
-  parseProjectDeclaration
+  findProjectRole,
+  RepositoryPathSchema,
+  ProjectSlugSchema,
+  ProjectRunModeSchema,
+  ProjectRoleSchema,
+  ProjectRoleCommandSchema,
+  ProjectRequirementSchema,
+  ProjectRequirementPhaseSchema,
+  ProjectReleaseSchema,
+  ProjectMigrationsSchema,
+  ProjectListenerSchema,
+  ProjectIdentitySchema,
+  ProjectEnvVariableSchema,
+  ProjectEnvShapeSchema,
+  ProjectDescriptionSchema,
+  ProjectDeclarationSchema,
+  ProjectCommandSchema,
+  ProjectBuildSchema,
+  ProjectBuildInputSchema,
+  PROJECT_DECLARATION_SCHEMA_VERSION,
+  BindingVariableSchema
 };

package/dist/files.js

@@ -8,8 +8,8 @@ import {
   ManagedFileRefSchema
 } from "./index-6k1937bx.js";
 export {
-  ManagedFileError,
-  ManagedFilePathSchema,
+  createManagedFileBoundary,
   ManagedFileRefSchema,
-  createManagedFileBoundary
+  ManagedFilePathSchema,
+  ManagedFileError
 };

package/dist/index-1z5xxfst.js

@@ -0,0 +1,397 @@
+// src/agent-runtime/contained-files.ts
+import {
+  close as closeDescriptor,
+  constants,
+  existsSync,
+  fchmod,
+  fstat,
+  read as readDescriptor,
+  write as writeDescriptor
+} from "node:fs";
+import { lstat, open, readdir, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var FILE_TYPE_MASK = 61440;
+var FILE_TYPE_DIRECTORY = 16384;
+var FILE_TYPE_REGULAR = 32768;
+var FILE_TYPE_SYMLINK = 40960;
+function modeIs(mode, type) {
+  return (mode & FILE_TYPE_MASK) === type;
+}
+function hasFunctions(value, names) {
+  return typeof value === "object" && value !== null && names.every((name) => typeof Reflect.get(value, name) === "function");
+}
+var darwinBinding;
+function loadDarwinBinding() {
+  if (darwinBinding)
+    return darwinBinding;
+  const directory = path.dirname(fileURLToPath(import.meta.url));
+  const binary = `darwin-${process.arch}.node`;
+  const candidates = [
+    path.resolve(directory, "../native", binary),
+    path.resolve(directory, "../../native", binary)
+  ];
+  const selected = candidates.find((candidate) => existsSync(candidate));
+  if (!selected) {
+    throw new Error(`Contained filesystem operations need the packaged Darwin ${process.arch} backend`);
+  }
+  const loaded = createRequire(import.meta.url)(selected);
+  const methods = [
+    "openDirectoryAt",
+    "openFileAt",
+    "createFileAt",
+    "statAt",
+    "listAt",
+    "renameAt",
+    "unlinkAt"
+  ];
+  if (!hasFunctions(loaded, methods)) {
+    throw new Error("The packaged Darwin contained-files backend has an invalid surface");
+  }
+  darwinBinding = loaded;
+  return darwinBinding;
+}
+
+class NumericFileHandle {
+  fd;
+  constructor(fd) {
+    this.fd = fd;
+  }
+  close() {
+    return new Promise((resolve, reject) => {
+      closeDescriptor(this.fd, (error) => error ? reject(error) : resolve());
+    });
+  }
+  read(buffer, offset, length, position) {
+    return new Promise((resolve, reject) => {
+      readDescriptor(this.fd, buffer, offset, length, position, (error, bytesRead) => error ? reject(error) : resolve({ bytesRead }));
+    });
+  }
+  stat() {
+    return new Promise((resolve, reject) => {
+      fstat(this.fd, (error, metadata) => error ? reject(error) : resolve(metadata));
+    });
+  }
+}
+function descriptorPath(handle) {
+  if (process.platform === "linux")
+    return `/proc/self/fd/${handle.fd}`;
+  throw new Error("Descriptor paths are available only in the Linux contained-files backend");
+}
+function sameIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+async function openPinnedDirectory(absolute) {
+  if (process.platform !== "linux" && process.platform !== "darwin") {
+    throw new Error("Contained filesystem operations support Linux and macOS only");
+  }
+  const expected = await realpath(absolute);
+  const handle = await open(expected, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    const [pathMetadata, handleMetadata] = await Promise.all([lstat(expected), handle.stat()]);
+    if (!pathMetadata.isDirectory() || !sameIdentity(pathMetadata, handleMetadata)) {
+      throw new Error("Contained directory identity changed while opening");
+    }
+    return handle;
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+function safeSegments(relative) {
+  if (path.isAbsolute(relative))
+    throw new Error("Contained paths must be relative");
+  const segments = relative.split(/[\\/]/u);
+  if (segments.length === 0 || segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    throw new Error("Contained path has invalid segments");
+  }
+  return segments;
+}
+async function openDirectoryAt(directory, name) {
+  if (process.platform === "darwin") {
+    return new NumericFileHandle(loadDarwinBinding().openDirectoryAt(directory.fd, name));
+  }
+  return open(path.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+}
+async function openFileAt(directory, name) {
+  if (process.platform === "darwin") {
+    return new NumericFileHandle(loadDarwinBinding().openFileAt(directory.fd, name));
+  }
+  return open(path.join(descriptorPath(directory), name), constants.O_RDONLY | constants.O_NOFOLLOW);
+}
+function entryMetadata(mode) {
+  return {
+    mode,
+    isDirectory: () => modeIs(mode, FILE_TYPE_DIRECTORY),
+    isFile: () => modeIs(mode, FILE_TYPE_REGULAR),
+    isSymbolicLink: () => modeIs(mode, FILE_TYPE_SYMLINK)
+  };
+}
+async function statAt(directory, name) {
+  if (process.platform === "darwin") {
+    const metadata = loadDarwinBinding().statAt(directory.fd, name);
+    return metadata ? entryMetadata(metadata.mode) : null;
+  }
+  return lstat(path.join(descriptorPath(directory), name)).catch((error) => {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  });
+}
+async function listAt(directory) {
+  if (process.platform === "darwin") {
+    return loadDarwinBinding().listAt(directory.fd).map(({ name, mode }) => ({ name, ...entryMetadata(mode) }));
+  }
+  return readdir(descriptorPath(directory), { withFileTypes: true });
+}
+async function openContainedParent(root, relative) {
+  const segments = safeSegments(relative);
+  const basename = segments.pop();
+  if (!basename)
+    throw new Error("Contained path is missing a basename");
+  let current = await openPinnedDirectory(root);
+  try {
+    for (const segment of segments) {
+      const next = await openDirectoryAt(current, segment);
+      const metadata = await next.stat();
+      if (!metadata.isDirectory()) {
+        await next.close();
+        throw new Error("Contained ancestor is not a directory");
+      }
+      await current.close();
+      current = next;
+    }
+    return { handle: current, basename };
+  } catch (error) {
+    await current.close();
+    throw error;
+  }
+}
+async function openContainedFile(root, relative) {
+  const parent = await openContainedParent(root, relative);
+  try {
+    const handle = await openFileAt(parent.handle, parent.basename);
+    const metadata = await handle.stat();
+    if (!metadata.isFile()) {
+      await handle.close();
+      throw new Error("Contained path is not a regular file");
+    }
+    return handle;
+  } finally {
+    await parent.handle.close();
+  }
+}
+async function assertContainedFileCurrent(root, relative, expected) {
+  const current = await openContainedFile(root, relative);
+  try {
+    if (!sameIdentity(await expected.stat(), await current.stat())) {
+      throw new Error("Contained file identity changed during authorization");
+    }
+  } finally {
+    await current.close();
+  }
+}
+async function assertContainedParentCurrent(root, relative, expected) {
+  const current = await openContainedParent(root, relative);
+  try {
+    if (!sameIdentity(await expected.stat(), await current.handle.stat())) {
+      throw new Error("Contained parent identity changed during authorization");
+    }
+  } finally {
+    await current.handle.close();
+  }
+}
+async function writeDescriptorFully(descriptor, content) {
+  const bytes = Buffer.from(content);
+  let offset = 0;
+  while (offset < bytes.byteLength) {
+    const written = await new Promise((resolve, reject) => {
+      writeDescriptor(descriptor, bytes, offset, bytes.byteLength - offset, null, (error, bytesWritten) => error ? reject(error) : resolve(bytesWritten));
+    });
+    if (written === 0)
+      throw new Error("Contained file write made no progress");
+    offset += written;
+  }
+}
+async function chmodDescriptor(descriptor, mode) {
+  await new Promise((resolve, reject) => {
+    fchmod(descriptor, mode & 4095, (error) => error ? reject(error) : resolve());
+  });
+}
+async function createDarwinFile(parent, name, content, mode) {
+  const binding = loadDarwinBinding();
+  const descriptor = binding.createFileAt(parent.fd, name, mode & 4095);
+  let failed;
+  try {
+    await writeDescriptorFully(descriptor, content);
+    await chmodDescriptor(descriptor, mode);
+  } catch (error) {
+    failed = error;
+  } finally {
+    try {
+      await new NumericFileHandle(descriptor).close();
+    } catch (error) {
+      failed ??= error;
+    }
+  }
+  if (failed) {
+    binding.unlinkAt(parent.fd, name);
+    throw failed;
+  }
+}
+async function writeContainedFile(input) {
+  const mode = input.mode ?? 438;
+  if (!input.replace) {
+    if (process.platform === "darwin") {
+      await createDarwinFile(input.parent.handle, input.parent.basename, input.content, mode);
+      return;
+    }
+    await writeFile(path.join(descriptorPath(input.parent.handle), input.parent.basename), input.content, { flag: "wx", mode });
+    return;
+  }
+  const temporary = `.${input.parent.basename}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  if (process.platform === "darwin") {
+    const binding = loadDarwinBinding();
+    let created = false;
+    try {
+      await createDarwinFile(input.parent.handle, temporary, input.content, mode);
+      created = true;
+      binding.renameAt(input.parent.handle.fd, temporary, input.parent.basename);
+    } catch (error) {
+      if (created)
+        binding.unlinkAt(input.parent.handle.fd, temporary);
+      throw error;
+    }
+    return;
+  }
+  const directory = descriptorPath(input.parent.handle);
+  const temporaryPath = path.join(directory, temporary);
+  try {
+    await writeFile(temporaryPath, input.content, { flag: "wx", mode });
+    await rename(temporaryPath, path.join(directory, input.parent.basename));
+  } catch (error) {
+    await unlink(temporaryPath).catch(() => {
+      return;
+    });
+    throw error;
+  }
+}
+async function containedEntryMetadata(parent) {
+  return statAt(parent.handle, parent.basename);
+}
+async function openContainedParentFile(parent) {
+  const handle = await openFileAt(parent.handle, parent.basename);
+  if (!(await handle.stat()).isFile()) {
+    await handle.close();
+    throw new Error("Contained path is not a regular file");
+  }
+  return handle;
+}
+async function readContainedUtf8Handle(handle, maxBytes) {
+  const metadata = await handle.stat();
+  if (!metadata.isFile())
+    throw new Error("Contained path is not a regular file");
+  if (metadata.size > maxBytes)
+    throw new Error("Contained file exceeds byte budget");
+  const buffer = Buffer.alloc(metadata.size);
+  let offset = 0;
+  while (offset < buffer.byteLength) {
+    const { bytesRead } = await handle.read(buffer, offset, buffer.byteLength - offset, offset);
+    if (bytesRead === 0)
+      break;
+    offset += bytesRead;
+  }
+  if (offset !== metadata.size)
+    throw new Error("Contained file changed while being read");
+  return {
+    text: new TextDecoder("utf-8", { fatal: true }).decode(buffer),
+    bytes: offset,
+    mode: metadata.mode
+  };
+}
+async function walkContainedFiles(input) {
+  const scan = await scanContainedFiles({ ...input, symlinks: "refuse" });
+  if (scan.truncated)
+    throw new Error("Contained file traversal exceeded its bounds");
+  return scan.files;
+}
+async function scanContainedFiles(input) {
+  const files = [];
+  let truncated = false;
+  let skippedDirectories = 0;
+  let skippedSymlinks = 0;
+  const root = await openPinnedDirectory(input.root);
+  const visit = async (directory, relativeDirectory, depth) => {
+    if (truncated)
+      return;
+    if (depth > input.maxDepth) {
+      truncated = true;
+      return;
+    }
+    const entries = [...await listAt(directory)];
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const relative = relativeDirectory ? path.join(relativeDirectory, entry.name) : entry.name;
+      if (entry.isSymbolicLink()) {
+        if (input.symlinks === "refuse") {
+          throw new Error(`Contained file traversal refuses symlink: ${relative}`);
+        }
+        skippedSymlinks += 1;
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (input.excludeDirectory?.(relative)) {
+          skippedDirectories += 1;
+          continue;
+        }
+        let child;
+        try {
+          child = await openDirectoryAt(directory, entry.name);
+        } catch (error) {
+          if (input.symlinks === "skip") {
+            skippedSymlinks += 1;
+            continue;
+          }
+          throw error;
+        }
+        try {
+          await visit(child, relative, depth + 1);
+        } finally {
+          await child.close();
+        }
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      if (files.length >= input.maxFiles) {
+        truncated = true;
+        return;
+      }
+      let content;
+      if (input.readMaxBytes !== undefined) {
+        try {
+          const handle = await openFileAt(directory, entry.name);
+          try {
+            content = await readContainedUtf8Handle(handle, input.readMaxBytes);
+          } finally {
+            await handle.close();
+          }
+        } catch (error) {
+          if (input.skipUnreadable)
+            continue;
+          throw error;
+        }
+      }
+      files.push({ absolute: relative, relative, ...content && { content } });
+    }
+  };
+  try {
+    await visit(root, "", 0);
+  } finally {
+    await root.close();
+  }
+  return { files, truncated, skippedDirectories, skippedSymlinks };
+}
+
+export { openContainedParent, openContainedFile, assertContainedFileCurrent, assertContainedParentCurrent, writeContainedFile, containedEntryMetadata, openContainedParentFile, readContainedUtf8Handle, walkContainedFiles, scanContainedFiles };

package/dist/{index-vy5bjy07.js → index-4qfqy0m6.js}

@@ -1,8 +1,11 @@
 import {
+  advanceToolChronology,
   assistantStatus,
+  canProjectToolChronology,
+  createToolChronology,
   isAssistantHistoryEvidence,
   isCompleteAgentHistoryTurn
-} from "./index-es0h4w26.js";
+} from "./index-y2s6h5bf.js";
 import {
   createBoundedSinkManager
 } from "./index-a59da114.js";
@@ -511,42 +514,20 @@ function interruptedSystemNote(message) {
   rendered.add("control");
   return { text: `[interrupted] partial response: ${text}`, rendered };
 }
-function completeToolChronology(message) {
-  const pending = new Set;
-  const completed = new Set;
-  let resultsStarted = false;
-  for (const part of message.parts) {
-    if (part.type === "tool-call") {
-      if (resultsStarted && pending.size > 0)
-        return false;
-      if (pending.size === 0)
-        resultsStarted = false;
-      if (pending.has(part.callId) || completed.has(part.callId))
-        return false;
-      pending.add(part.callId);
-    }
-    if (part.type === "tool-result") {
-      if (!pending.delete(part.callId))
-        return false;
-      completed.add(part.callId);
-      resultsStarted = true;
-    }
-    if (part.type === "tool-approval-request") {
-      if (!pending.delete(part.callId))
-        return false;
-      completed.add(part.callId);
-      resultsStarted = true;
-    }
-  }
-  return pending.size === 0;
-}
 async function projectAgentHistoryDetailed(messages, options = {}) {
   const projected = [];
   const system = [];
   const decisions = [];
   const interruptedRule = options.interruptedAssistant ?? "assistant-marked";
   let observedUser = false;
+  let chronology = createToolChronology();
+  let conversationId;
   for (const message of messages) {
+    if (message.conversationId !== conversationId) {
+      conversationId = message.conversationId;
+      chronology = createToolChronology();
+      observedUser = false;
+    }
     if (message.role === "assistant" && !isAssistantHistoryEvidence(message.status, options.evidencePolicy)) {
       decisions.push(decide(message, "omitted", message.status === "superseded" ? "superseded" : "draft-or-failed"));
       continue;
@@ -557,6 +538,8 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
     }
     if (message.role === "user") {
       const user = await userMessage(message, options);
+      if (chronology.pending === 0)
+        chronology = createToolChronology();
       observedUser = true;
       if (user.message) {
         projected.push(user.message);
@@ -598,7 +581,8 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
       }
       continue;
     }
-    if (!completeToolChronology(message)) {
+    const nextChronology = advanceToolChronology(chronology, message.parts);
+    if (!nextChronology || !canProjectToolChronology(nextChronology)) {
       if (options.incompleteToolTurn === "error") {
         throw new Error(`Assistant message ${message.id} has incomplete tool chronology`);
       }
@@ -606,6 +590,7 @@ async function projectAgentHistoryDetailed(messages, options = {}) {
       continue;
     }
     const assistant = assistantMessages(message, interrupted ? "interrupted" : message.status === "failed" ? "failed" : undefined);
+    chronology = nextChronology;
     projected.push(...assistant.messages);
     decisions.push(assistant.messages.length > 0 ? decide(message, "projected", "projected", assistant.rendered) : decide(message, "omitted", "empty"));
   }
@@ -1477,6 +1462,11 @@ function createRunExecutor(dependencies) {
             evidencePolicy: config.history.evidencePolicy
           }
         });
+        for (const decision of detailed.decisions) {
+          if (decision.action === "omitted" && run.inputMessageIds.includes(decision.messageId) && source.messages.some((message) => message.id === decision.messageId && message.role === "tool")) {
+            throw new Error(`Invalid approval continuation ${decision.messageId}: ${decision.reason}`);
+          }
+        }
         carriedSystem = detailed.system;
         return [...detailed.messages];
       };

package/dist/{index-dk6e56g0.js → index-7wpgrqa8.js}

@@ -10,6 +10,7 @@ var ShutdownStateSchema = z.enum([
 ]);
 var ShutdownOptionsSchema = z.object({
   gracePeriodMs: z.number().int().nonnegative().default(30000),
+  realtimeCloseTimeoutMs: z.number().int().nonnegative().default(1000),
   forceTimeoutMs: z.number().int().nonnegative().default(5000),
   retryAfterSeconds: z.number().int().nonnegative().default(5),
   signal: z.custom((value) => typeof value === "object" && value !== null && ("aborted" in value) && ("addEventListener" in value), "Expected an AbortSignal").optional()
@@ -63,6 +64,32 @@ function untilAbort(signal) {
     return Promise.resolve();
   return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
 }
+function closeRealtimeWithin(adapter, timeoutMs, signal) {
+  if (signal.aborted)
+    return Promise.resolve("aborted");
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      resolve(outcome);
+    };
+    const onAbort = () => finish("aborted");
+    const timer = setTimeout(() => finish("timeout"), timeoutMs);
+    signal.addEventListener("abort", onAbort, { once: true });
+    adapter.closeRealtime().then(() => finish("closed"), (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    });
+  });
+}
 function withTimeout(promise, timeoutMs, message) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
@@ -119,6 +146,7 @@ function createServerLifecycle(getAdapter) {
       const phaseAbort = new AbortController;
       let forcedReason;
       let phaseError;
+      let forcedWebSockets = 0;
       const force = (reason) => {
         if (forcedReason)
           return;
@@ -139,7 +167,13 @@ function createServerLifecycle(getAdapter) {
           await waitForZero(() => pendingApplicationRequests, phaseAbort.signal);
           if (!forcedReason) {
             state = "closing-realtime";
-            await Promise.race([adapter.closeRealtime(), untilAbort(phaseAbort.signal)]);
+            const realtimeOutcome = await closeRealtimeWithin(adapter, parsed.realtimeCloseTimeoutMs, phaseAbort.signal);
+            if (!forcedReason && realtimeOutcome === "timeout" && adapter.pendingWebSockets() > 0) {
+              forcedWebSockets += await Promise.race([
+                adapter.terminateRealtime(),
+                untilAbort(phaseAbort.signal).then(() => 0)
+              ]);
+            }
           }
           if (!forcedReason) {
             state = "stopping-runtime";
@@ -157,6 +191,7 @@ function createServerLifecycle(getAdapter) {
           state = "stopping-runtime";
           pendingRequestsAtForce = adapter.pendingRequests();
           pendingWebSocketsAtForce = adapter.pendingWebSockets();
+          forcedWebSockets += pendingWebSocketsAtForce;
           let forceError;
           let forceFailed = false;
           try {
@@ -189,7 +224,7 @@ function createServerLifecycle(getAdapter) {
           pendingRequestsAtForce,
           pendingWebSocketsAtForce,
           abortedRequests: pendingRequestsAtForce,
-          forcedWebSockets: pendingWebSocketsAtForce,
+          forcedWebSockets,
           durationMs: performance.now() - startedAt
         }));
       })().catch((error) => {

package/dist/{index-10gbbbaa.js → index-9sx8tbz2.js}

@@ -8,7 +8,7 @@ import {
   AgentRuntimeHeadSchema,
   AgentStoredRunSchema,
   createAgentRuntimeStore
-} from "./index-hsabxjz0.js";
+} from "./index-jw81xr75.js";
 import {
   AgentMessageSchema,
   AgentRunSchema