stitchkit 0.68.10 → 0.69.0

package/dist/{index-xyvxez9r.js → index-q7gdep2c.js}

@@ -2,20 +2,20 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-hxh98zbm.js";
+} from "./index-d1jsvkyk.js";
 import {
   base64UrlToBytes,
   bytesToBase64Url,
   isUnsafeKey,
   safeJsonParse
-} from "./index-pgsyp3xh.js";
-import {
-  isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-x18ndp4p.js";
 import {
   forbidden,
   unauthorized
 } from "./index-0w9abg87.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
 
 // src/server/middleware/cookies.ts
 function parseCookies(header) {

package/dist/{index-t23p2b68.js → index-t4dpby6e.js}

@@ -1,6 +1,6 @@
 import {
   normalizeError
-} from "./index-pgsyp3xh.js";
+} from "./index-x18ndp4p.js";
 
 // src/internal/bounded-lines.ts
 var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;

package/dist/index-tg3m2ec5.js

@@ -0,0 +1,157 @@
+// src/agent-runtime/models.ts
+import { z } from "zod";
+var AgentModelCapabilitySchema = z.enum(["tools", "vision", "reasoning", "files"]);
+var AgentModelDescriptorSchema = z.object({
+  provider: z.string().min(1),
+  modelId: z.string().min(1),
+  contextWindow: z.int().positive(),
+  capabilities: z.array(AgentModelCapabilitySchema),
+  observedAt: z.iso.datetime({ offset: true }).optional(),
+  source: z.string().min(1).optional(),
+  availability: z.enum(["available", "unavailable"]).optional()
+});
+var AgentModelRegistrySnapshotSchema = z.object({
+  schemaVersion: z.literal(1),
+  source: z.string().min(1),
+  observedAt: z.iso.datetime({ offset: true }),
+  models: z.record(z.string().min(1), AgentModelDescriptorSchema)
+});
+var AgentModelPriceSchema = z.object({
+  currency: z.string().length(3),
+  inputPerToken: z.string().regex(/^\d+(?:\.\d+)?$/).optional(),
+  outputPerToken: z.string().regex(/^\d+(?:\.\d+)?$/).optional()
+}).strict();
+var AgentModelMetricSchema = z.object({
+  metric: z.string().min(1),
+  value: z.number(),
+  unit: z.enum(["index", "elo", "percent", "milliseconds"]),
+  source: z.string().min(1),
+  observedAt: z.iso.datetime({ offset: true })
+}).strict();
+var AgentModelPopularitySchema = z.object({
+  rank: z.int().positive(),
+  window: z.literal("week"),
+  source: z.string().min(1),
+  observedAt: z.iso.datetime({ offset: true })
+}).strict();
+var AgentModelCatalogEntrySchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  descriptor: AgentModelDescriptorSchema,
+  description: z.string().optional(),
+  price: AgentModelPriceSchema.optional(),
+  popularity: AgentModelPopularitySchema.optional(),
+  metrics: z.array(AgentModelMetricSchema)
+}).strict();
+var AgentModelCatalogSchema = z.object({
+  schemaVersion: z.literal(1),
+  source: z.string().min(1),
+  observedAt: z.iso.datetime({ offset: true }),
+  completeness: z.enum(["complete", "partial"]),
+  models: z.array(AgentModelCatalogEntrySchema),
+  diagnostics: z.array(z.string())
+}).strict();
+var AgentModelSelectionSchema = z.object({
+  modelId: z.string().min(1),
+  selectedAt: z.iso.datetime({ offset: true })
+}).strict();
+var AgentModelSearchInputSchema = z.object({ query: z.string().max(256).default(""), limit: z.int().positive().max(200) }).strict();
+var AgentModelSearchResultSchema = z.object({
+  models: z.array(AgentModelCatalogEntrySchema),
+  total: z.int().nonnegative(),
+  truncated: z.boolean()
+}).strict();
+function searchAgentModelCatalog(catalog, rawInput) {
+  const input = AgentModelSearchInputSchema.parse(rawInput);
+  const terms = input.query.toLocaleLowerCase().trim().split(/\s+/).filter(Boolean);
+  const matches = catalog.models.filter((model) => {
+    const searchable = `${model.id}
+${model.name}
+${model.description ?? ""}`.toLocaleLowerCase();
+    return terms.every((term) => searchable.includes(term));
+  });
+  return AgentModelSearchResultSchema.parse({
+    models: matches.slice(0, input.limit),
+    total: matches.length,
+    truncated: matches.length > input.limit
+  });
+}
+function createMemoryAgentModelSelectionStore() {
+  const selections = new Map;
+  return {
+    load: (conversationId) => selections.get(conversationId),
+    save(conversationId, rawSelection) {
+      selections.set(conversationId, AgentModelSelectionSchema.parse(rawSelection));
+    }
+  };
+}
+function defineModelRegistry(config) {
+  const descriptors = new Map;
+  for (const key in config.models) {
+    const declaration = config.models[key];
+    if (declaration)
+      descriptors.set(key, AgentModelDescriptorSchema.parse(declaration));
+  }
+  const descriptor = (key) => {
+    const found = descriptors.get(key);
+    if (!found)
+      throw new Error(`Unknown agent model: ${key}`);
+    return found;
+  };
+  const supports = (key, capabilities) => {
+    const available = new Set(descriptor(key).capabilities);
+    return capabilities.every((capability) => available.has(capability));
+  };
+  const preflight = (key, required = []) => {
+    const selected = descriptor(key);
+    if (selected.availability === "unavailable") {
+      throw new Error(`Agent model ${key} is unavailable`);
+    }
+    if (!supports(key, required)) {
+      throw new Error(`Agent model ${key} does not satisfy required capabilities`);
+    }
+    if (!config.providers[selected.provider]) {
+      throw new Error(`Unknown agent model provider: ${selected.provider}`);
+    }
+    return selected;
+  };
+  return {
+    keys: () => [...descriptors.keys()],
+    descriptor,
+    supports,
+    preflight,
+    resolve(key, required = []) {
+      const selected = preflight(key, required);
+      const provider = config.providers[selected.provider];
+      if (!provider)
+        throw new Error(`Unknown agent model provider: ${selected.provider}`);
+      return {
+        descriptor: selected,
+        model: provider.create(selected.modelId),
+        ...provider.normalizeUsage && { normalizeUsage: provider.normalizeUsage }
+      };
+    },
+    snapshot(input) {
+      return AgentModelRegistrySnapshotSchema.parse({
+        schemaVersion: 1,
+        source: input.source,
+        observedAt: input.observedAt,
+        models: Object.fromEntries(descriptors.entries())
+      });
+    }
+  };
+}
+function validateAgentModelSnapshot(input, policy) {
+  if (!Number.isSafeInteger(policy.maxAgeMs) || policy.maxAgeMs < 0) {
+    throw new TypeError("maxAgeMs must be a non-negative safe integer");
+  }
+  const snapshot = AgentModelRegistrySnapshotSchema.parse(input);
+  const now = policy.now?.() ?? new Date;
+  const age = now.getTime() - new Date(snapshot.observedAt).getTime();
+  if (age < 0 || age > policy.maxAgeMs) {
+    throw new Error(`Agent model snapshot from ${snapshot.source} is stale`);
+  }
+  return snapshot;
+}
+
+export { AgentModelCapabilitySchema, AgentModelDescriptorSchema, AgentModelRegistrySnapshotSchema, AgentModelPriceSchema, AgentModelMetricSchema, AgentModelPopularitySchema, AgentModelCatalogEntrySchema, AgentModelCatalogSchema, AgentModelSelectionSchema, AgentModelSearchInputSchema, AgentModelSearchResultSchema, searchAgentModelCatalog, createMemoryAgentModelSelectionStore, defineModelRegistry, validateAgentModelSnapshot };

package/dist/index-v3dpzpjw.js

@@ -0,0 +1,92 @@
+// src/agent-runtime/contained-files.ts
+import { constants } from "node:fs";
+import { lstat, open, readdir, realpath } from "node:fs/promises";
+import path from "node:path";
+async function readContainedUtf8File(absolute, maxBytes) {
+  const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    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
+    };
+  } finally {
+    await handle.close();
+  }
+}
+function inside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+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 root = await realpath(input.root);
+  const files = [];
+  let truncated = false;
+  let skippedDirectories = 0;
+  let skippedSymlinks = 0;
+  const visit = async (directory, depth) => {
+    if (truncated)
+      return;
+    if (depth > input.maxDepth) {
+      truncated = true;
+      return;
+    }
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const absolute = path.join(directory, entry.name);
+      const metadata = await lstat(absolute);
+      if (metadata.isSymbolicLink()) {
+        if (input.symlinks === "refuse") {
+          throw new Error(`Contained file traversal refuses symlink: ${path.relative(root, absolute)}`);
+        }
+        skippedSymlinks += 1;
+        continue;
+      }
+      if (metadata.isDirectory()) {
+        const relative = path.relative(root, absolute);
+        if (input.excludeDirectory?.(relative)) {
+          skippedDirectories += 1;
+          continue;
+        }
+        await visit(absolute, depth + 1);
+        continue;
+      }
+      if (!metadata.isFile())
+        continue;
+      const resolved = await realpath(absolute);
+      if (!inside(root, resolved))
+        throw new Error("Contained file traversal escaped root");
+      if (files.length >= input.maxFiles) {
+        truncated = true;
+        return;
+      }
+      files.push({ absolute: resolved, relative: path.relative(root, resolved) });
+    }
+  };
+  await visit(root, 0);
+  return { files, truncated, skippedDirectories, skippedSymlinks };
+}
+
+export { readContainedUtf8File, walkContainedFiles, scanContainedFiles };

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

@@ -1,9 +1,5 @@
 import {
-  contractToolMountable
-} from "./index-y2ctppmg.js";
-import {
-  projectRuntimeTool,
-  projectToolSurface
+  projectRuntimeTool
 } from "./index-22by16v6.js";
 
 // src/tools/runtime-tool.ts
@@ -87,44 +83,4 @@ function runtimeToolMountable(definition, assertName = true) {
   };
 }
 
-// src/tools/surface.ts
-function collectToolSurface({
-  surface,
-  transport,
-  assertUniqueNames = true,
-  ...collectConfig
-}) {
-  const entries = [];
-  const append = (entry) => {
-    entries.push(entry);
-  };
-  for (const projected of projectToolSurface(surface, transport, {
-    extend: collectConfig.extend,
-    flattenUnionInput: collectConfig.flattenUnionInput,
-    assertNames: collectConfig.assertNames,
-    assertUniqueNames
-  })) {
-    if (projected.kind === "contract") {
-      const mountable = contractToolMountable(projected, collectConfig.extend);
-      append({
-        kind: "contract",
-        service: projected.serviceName,
-        action: mountable.method.key,
-        mountable,
-        projection: projected
-      });
-    } else {
-      append({
-        kind: "runtime",
-        service: projected.serviceName,
-        action: projected.action,
-        mountable: runtimeToolMountable(projected.source, false),
-        definition: projected.source,
-        projection: projected
-      });
-    }
-  }
-  return entries;
-}
-
-export { defineRuntimeTool, createRuntimeToolFactory, collectToolSurface };
+export { defineRuntimeTool, createRuntimeToolFactory, runtimeToolMountable };

package/dist/{index-ysphyxax.js → index-x1th9s8c.js}

@@ -44,6 +44,19 @@ var AgentToolResultPartSchema = z.object({
   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
@@ -59,10 +72,18 @@ var AgentMessagePartSchema = z.discriminatedUnion("type", [
   AgentSourcePartSchema,
   AgentToolCallPartSchema,
   AgentToolResultPartSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
   AgentOpaquePartSchema,
   AgentControlPartSchema
 ]);
-var AgentMessageRoleSchema = z.enum(["user", "assistant", "system", "summary"]);
+var AgentMessageRoleSchema = z.enum([
+  "user",
+  "assistant",
+  "tool",
+  "system",
+  "summary"
+]);
 var AgentMessageStatusSchema = z.enum([
   "committed",
   "streaming",
@@ -256,4 +277,4 @@ var AgentRunMetricsSchema = z.object({
   ttftMs: z.number().nonnegative().optional()
 });
 
-export { AgentRecordIdSchema, AgentRecordVersionSchema, AgentTimestampSchema, AgentJsonObjectSchema, AgentProviderEnvelopeSchema, AgentTextPartSchema, AgentReasoningPartSchema, AgentFilePartSchema, AgentSourcePartSchema, AgentToolCallPartSchema, AgentToolResultPartSchema, AgentOpaquePartSchema, AgentControlPartSchema, AgentMessagePartSchema, AgentMessageRoleSchema, AgentMessageStatusSchema, AgentMessageSchema, AgentAssistantPlaceholderSchema, AgentRunStateSchema, AgentRunQueuePrioritySchema, AgentTerminalReasonSchema, runStateForTerminalReason, AgentProvenanceSchema, AgentUsageValueSchema, AgentCostValueSchema, AgentUsageSchema, AgentRunSchema, AgentSnapshotSchema, AgentRunMetricsSchema };
+export { AgentRecordIdSchema, AgentRecordVersionSchema, AgentTimestampSchema, AgentJsonObjectSchema, AgentProviderEnvelopeSchema, AgentTextPartSchema, AgentReasoningPartSchema, AgentFilePartSchema, AgentSourcePartSchema, AgentToolCallPartSchema, AgentToolResultPartSchema, AgentToolApprovalRequestPartSchema, AgentToolApprovalResponsePartSchema, AgentOpaquePartSchema, AgentControlPartSchema, AgentMessagePartSchema, AgentMessageRoleSchema, AgentMessageStatusSchema, AgentMessageSchema, AgentAssistantPlaceholderSchema, AgentRunStateSchema, AgentRunQueuePrioritySchema, AgentTerminalReasonSchema, runStateForTerminalReason, AgentProvenanceSchema, AgentUsageValueSchema, AgentCostValueSchema, AgentUsageSchema, AgentRunSchema, AgentSnapshotSchema, AgentRunMetricsSchema };

package/dist/index-xxsq3ca1.js

@@ -0,0 +1,51 @@
+import {
+  runtimeToolMountable
+} from "./index-wwst0td5.js";
+import {
+  contractToolMountable
+} from "./index-kg9xx84n.js";
+import {
+  projectToolSurface
+} from "./index-22by16v6.js";
+
+// src/tools/surface.ts
+function collectToolSurface({
+  surface,
+  transport,
+  assertUniqueNames = true,
+  ...collectConfig
+}) {
+  const entries = [];
+  const append = (entry) => {
+    entries.push(entry);
+  };
+  for (const projected of projectToolSurface(surface, transport, {
+    extend: collectConfig.extend,
+    flattenUnionInput: collectConfig.flattenUnionInput,
+    assertNames: collectConfig.assertNames,
+    assertUniqueNames
+  })) {
+    if (projected.kind === "contract") {
+      const mountable = contractToolMountable(projected, collectConfig.extend);
+      append({
+        kind: "contract",
+        service: projected.serviceName,
+        action: mountable.method.key,
+        mountable,
+        projection: projected
+      });
+    } else {
+      append({
+        kind: "runtime",
+        service: projected.serviceName,
+        action: projected.action,
+        mountable: runtimeToolMountable(projected.source, false),
+        definition: projected.source,
+        projection: projected
+      });
+    }
+  }
+  return entries;
+}
+
+export { collectToolSurface };

package/dist/{index-22tjt2rk.js → index-zh459sfj.js}

@@ -1,6 +1,6 @@
 import {
   isUnsafeKey
-} from "./index-pgsyp3xh.js";
+} from "./index-x18ndp4p.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";