stitchkit 0.93.0 → 0.94.0

package/dist/{index-kw9t5ayn.js → index-cq4qfycf.js}

@@ -1,4 +1,4 @@
-// src/agent-runtime/durability-contract.ts
+// src/durability/contract.ts
 import { z } from "zod";
 var DURABILITY_STEP_EVENT_KIND = "durability/step";
 var DURABILITY_PARK_EVENT_KIND = "durability/park";
@@ -68,7 +68,7 @@ class ParkAbortedError extends Error {
   }
 }
 
-// src/agent-runtime/durability-json.ts
+// src/durability/json.ts
 import { z as z2 } from "zod";
 function losslessJson(value, ancestors = new Set, depth = 0) {
   if (depth > 100)
@@ -109,7 +109,7 @@ function losslessJson(value, ancestors = new Set, depth = 0) {
 }
 var DurableJsonSchema = z2.custom((value) => losslessJson(value), "Expected lossless JSON data (finite numbers, plain objects and dense arrays; no accessors)");
 
-// src/agent-runtime/durability-ledger.ts
+// src/durability/ledger.ts
 function stepKey(conversationId, runId, stepName) {
   return JSON.stringify([conversationId, runId, stepName]);
 }
@@ -216,7 +216,7 @@ async function readDurabilityLedger(store, conversationId, view) {
   return view;
 }
 
-// src/agent-runtime/durability-scheduler.ts
+// src/durability/scheduler.ts
 var systemClock = {
   now: () => Date.now(),
   schedule(callback, delayMs) {
@@ -300,7 +300,7 @@ function createParkWaiter(parkWaiters, key, signal) {
   return { outcome, cancel: cleanup };
 }
 
-// src/agent-runtime/durability.ts
+// src/durability/engine.ts
 function releaseSettled(registry, key, pending) {
   const release = () => {
     if (registry.get(key) === pending)

package/dist/{index-7gnkny4z.js → index-d9pk3td4.js}

@@ -1,4 +1,4 @@
-// src/application/channel.ts
+// src/internal/channel.ts
 import { z } from "zod";
 var PositiveSafeIntegerSchema = z.number().int().positive().safe();
 var BoundedChannelPolicySchema = z.enum(["ordered", "latest"]);

package/dist/{index-e42wzzz5.js → index-dcpdvjsc.js}

@@ -1,22 +1,22 @@
 import {
   AgentToolError,
   resolveToolDurability
-} from "./index-kw9t5ayn.js";
+} from "./index-cq4qfycf.js";
 import {
   collectToolSurface
-} from "./index-2c2bjw3s.js";
+} from "./index-vcvkq30w.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-mzvgxp0n.js";
+} from "./index-2cr1cqhn.js";
 import {
   isToolExecutionControlError,
   toolCauseFromResult,
   toolResultFromError
-} from "./index-yn8remb1.js";
+} from "./index-j05z5gn4.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/tools/agent.ts
 import { jsonSchema, tool } from "ai";
@@ -29,11 +29,11 @@ function mountAgent(services, config = {}) {
   const tools = {};
   const runTool = createToolRunner({
     source: "agent",
+    toolSurface: true,
     extend: config.extend,
     context: config.context,
     hooks: config.hooks,
     lifecycle: config.lifecycle,
-    errorHint: config.errorHint,
     coerceJsonArgs: config.coerceJsonArgs,
     onOutputStrip: config.onOutputStrip
   });
@@ -53,6 +53,7 @@ function mountAgent(services, config = {}) {
       const callContext = { signal: options.abortSignal, toolCallId: options.toolCallId };
       const executeTool = durability ? createToolRunner({
         source: "agent",
+        toolSurface: true,
         extend: config.extend,
         context: {
           ...config.context,
@@ -62,7 +63,6 @@ function mountAgent(services, config = {}) {
         },
         hooks: config.hooks,
         lifecycle: config.lifecycle,
-        errorHint: config.errorHint,
         coerceJsonArgs: config.coerceJsonArgs,
         onOutputStrip: config.onOutputStrip
       }) : runTool;

package/dist/{index-h9etkkyk.js → index-dydjcp8z.js}

@@ -1,11 +1,20 @@
 import {
   toJsonSchema
-} from "./index-cby4ar3v.js";
+} from "./index-eqqvgdb3.js";
+import {
+  validateDeclaredOutput
+} from "./index-znfs20ss.js";
+import {
+  AppError
+} from "./index-2vtcmrj9.js";
+import {
+  serializeCanonicalJson
+} from "./index-k5hsfc3j.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
-// src/tools/portable-formats.ts
+// src/tools/schema/portable-formats.ts
 var PORTABLE_JSON_SCHEMA_FORMATS = new Set([
   "date",
   "time",
@@ -91,7 +100,7 @@ function findNonPortableFormats(schema, allowFormats = []) {
   return found.sort((left, right) => left.path.localeCompare(right.path) || left.format.localeCompare(right.format));
 }
 
-// src/tools/flatten-join.ts
+// src/tools/schema/flatten-join.ts
 var ANNOTATION_KEYS = new Set(["$schema", "default", "description", "examples", "title"]);
 var TYPE_KEYWORDS = {
   array: [
@@ -161,13 +170,6 @@ function withoutAnnotations(schema) {
   }
   return result;
 }
-function stableJson(value) {
-  if (Array.isArray(value))
-    return `[${value.map(stableJson).join(",")}]`;
-  if (!isRecord(value))
-    return JSON.stringify(value) ?? "undefined";
-  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
-}
 function stringValues(schema) {
   if (typeof schema.const === "string")
     return [schema.const];
@@ -309,7 +311,7 @@ function mergePropertySchemas(properties) {
   const structural = schemas.map(withoutAnnotations);
   const [first] = structural;
   let merged;
-  if (first && structural.every((schema) => stableJson(schema) === stableJson(first))) {
+  if (first && structural.every((schema) => serializeCanonicalJson(schema) === serializeCanonicalJson(first))) {
     merged = structuredClone(first);
   } else {
     const values = schemas.map(stringValues);
@@ -324,7 +326,7 @@ function mergePropertySchemas(properties) {
   return merged;
 }
 
-// src/tools/flatten.ts
+// src/tools/schema/flatten.ts
 function rebuild(value) {
   if (Array.isArray(value))
     return value.map(rebuild);
@@ -478,7 +480,7 @@ function freezeJsonValue(value) {
   }
 }
 
-// src/tools/untyped-properties.ts
+// src/tools/schema/untyped-properties.ts
 var TYPE_KEYWORDS2 = ["type", "enum", "const", "anyOf", "oneOf", "allOf", "$ref", "not"];
 function saysWhatItIs(schema) {
   return TYPE_KEYWORDS2.some((keyword) => schema[keyword] !== undefined);
@@ -549,7 +551,54 @@ function findUntypedProperties(schema, prefix = "") {
   return found;
 }
 
-// src/tools/schema.ts
+// src/tools/internal/tool-view.ts
+function toolSurfaceOutputSchema(operation) {
+  if (!operation.outputSchema)
+    return;
+  return operation.toolView?.output ?? operation.outputSchema;
+}
+function applyToolViewDefaults(inputArgs, defaults) {
+  if (!defaults)
+    return inputArgs;
+  const filled = { ...inputArgs };
+  for (const [key, value] of Object.entries(defaults)) {
+    if (filled[key] === undefined)
+      filled[key] = structuredClone(value);
+  }
+  return filled;
+}
+function projectToolView(options) {
+  const { view } = options;
+  let projected = options.full;
+  if (view.project) {
+    try {
+      projected = Reflect.apply(view.project, undefined, [options.full, options.call]);
+    } catch (error) {
+      const failure = new AppError("INTERNAL_SERVER_ERROR", `${options.operation} toolView.project threw`, 500);
+      failure.cause = error;
+      throw failure;
+    }
+    if (isRecord(projected) && typeof projected.then === "function") {
+      Promise.resolve(projected).catch(() => {
+        return;
+      });
+      throw new AppError("INTERNAL_SERVER_ERROR", `${options.operation} toolView.project returned a Promise — it must be synchronous`, 500);
+    }
+    if (projected === undefined) {
+      return {
+        ok: false,
+        message: `${options.operation} toolView.project returned undefined`
+      };
+    }
+  }
+  const checked = validateDeclaredOutput(view.output ?? options.fullSchema, projected, view.project ? options.onStripped : undefined);
+  if (!checked.ok) {
+    return { ok: false, message: `${options.operation} toolView: ${checked.message}` };
+  }
+  return checked;
+}
+
+// src/tools/schema/schema.ts
 import { z } from "zod";
 function objectShapeKeys(schema) {
   return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
@@ -600,7 +649,7 @@ function mergeSchemas(paramsSchema, inputSchema) {
   return paramsObject ? z.intersection(paramsObject, inputSchema) : inputSchema;
 }
 
-// src/tools/mcp-round-policy.ts
+// src/tools/mcp/round-policy.ts
 function staticInputRounds(policy) {
   return Array.isArray(policy.inputRequired) ? policy.inputRequired : undefined;
 }
@@ -674,7 +723,7 @@ function hasUsableChars(value) {
 function assertToolName(name, serviceName, key) {
   const where = `service "${serviceName}", method "${key}"`;
   if (!TOOL_NAME_RE.test(name)) {
-    const why = name.length > 64 ? `is ${name.length} characters (max 64) — set an explicit \`toolName\`` : "must match [a-zA-Z0-9_-]";
+    const why = name.length > 64 ? `is ${name.length} characters (max 64) — set an explicit \`tool.name\`` : "must match [a-zA-Z0-9_-]";
     throw new Error(`Tool name "${name}" (${where}) ${why}`);
   }
 }
@@ -701,10 +750,10 @@ function assertUniqueToolName(name, taken, surface) {
   }
 }
 
-// src/tools/presentation.ts
+// src/tools/schema/presentation.ts
 import { z as z2 } from "zod";
 
-// src/tools/json-schema-dialect.ts
+// src/json-schema/dialect.ts
 var DRAFT_07_MARKER = "draft-07";
 var DRAFT_07_KEYWORD = "definitions";
 var DEFS_KEYWORD = "$defs";
@@ -736,7 +785,7 @@ function withDefsDialect(schema) {
   return rewritten;
 }
 
-// src/tools/presentation.ts
+// src/tools/schema/presentation.ts
 function withoutDialect(schema) {
   const result = {};
   for (const [key, value] of Object.entries(schema)) {
@@ -887,6 +936,8 @@ function buildToolPresentationSchema(config) {
       presentation = mergeObjectSchemas(withoutDialect(extra), withoutDialect(presentation), true);
     }
   }
+  if (config.defaults)
+    presentation = withToolDefaults(presentation, config.defaults);
   if (presentation.$schema === undefined) {
     presentation = {
       $schema: "http://json-schema.org/draft-07/schema#",
@@ -895,6 +946,27 @@ function buildToolPresentationSchema(config) {
   }
   return freezeToolJsonSchema(presentation);
 }
+function withToolDefaults(schema, defaults) {
+  const properties = objectProperties(schema);
+  if (!properties)
+    return schema;
+  const keys = Object.keys(defaults).filter((key) => isRecord(properties[key]));
+  if (keys.length === 0)
+    return schema;
+  const nextProperties = { ...properties };
+  for (const key of keys) {
+    const property = properties[key];
+    if (!isRecord(property))
+      continue;
+    const value = structuredClone(defaults[key]);
+    nextProperties[key] = typeof property.$ref === "string" ? { allOf: [property], default: value } : { ...property, default: value };
+  }
+  const required = requiredKeys2(schema).filter((key) => !keys.includes(key));
+  const next = { ...schema, properties: nextProperties };
+  if (Array.isArray(schema.required))
+    next.required = required;
+  return next;
+}
 function isObjectPresentationSchema(schema) {
   return schema.type === "object" && isRecord(schema.properties);
 }
@@ -947,7 +1019,7 @@ function assertProjectedName(name, serviceName, action, transport, derived) {
   if (transport === "CLI")
     return;
   if (derived && !hasUsableChars(serviceName)) {
-    throw new Error(`Service prefix "${serviceName}" (method "${action}") has no characters usable in a tool name — set an explicit \`toolName\` or rename the prefix`);
+    throw new Error(`Service prefix "${serviceName}" (method "${action}") has no characters usable in a tool name — set an explicit \`tool.name\` or rename the prefix`);
   }
   assertToolName(name, serviceName, action);
 }
@@ -996,6 +1068,7 @@ function projectToolSurface(surface, transport, config = {}) {
         presentationSchema: buildToolPresentationSchema({
           paramsSchema: method.paramsSchema,
           inputSchema: method.inputSchema,
+          defaults: method.toolView?.defaults,
           extendSchema: shouldExtend ? config.extend?.schema : undefined,
           flattenUnionInput: config.flattenUnionInput,
           unrepresentable: "any"
@@ -1026,8 +1099,11 @@ function mcpProjectionCandidate(tool) {
       ...tool.source.inputSchema !== undefined && {
         inputSchema: tool.source.inputSchema
       },
-      ...tool.source.outputSchema !== undefined && {
-        outputSchema: tool.source.outputSchema
+      ...tool.source.toolView?.defaults !== undefined && {
+        inputDefaults: tool.source.toolView.defaults
+      },
+      ...toolSurfaceOutputSchema(tool.source) !== undefined && {
+        outputSchema: toolSurfaceOutputSchema(tool.source)
       },
       shouldExtend: tool.shouldExtend,
       ...tool.mcp !== undefined && { mcp: tool.mcp }
@@ -1069,7 +1145,8 @@ function prepareProjectedMcpTools(tools, config = {}) {
         inputSchema: tool.inputSchema,
         extendSchema: tool.shouldExtend && config.extend ? config.extend.schema : undefined,
         flattenUnionInput: config.flattenUnionInput,
-        unrepresentable: "throw"
+        unrepresentable: "throw",
+        defaults: tool.inputDefaults
       });
     } catch (error) {
       reportIncompatible(`MCP tool "${tool.name}" — input schema is not JSON Schema-compatible: ${error instanceof Error ? error.message : String(error)}`, policy, config.logger, failures);
@@ -1123,4 +1200,4 @@ function prepareProjectedMcpTools(tools, config = {}) {
   return prepared;
 }
 
-export { objectShapeKeys, rebuildObject, mergeSchemas, staticInputRounds, validateMcpRoundPolicy, validateResolvedInputRounds, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, declaresDraft07, withDefsDialect, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };
+export { toolSurfaceOutputSchema, applyToolViewDefaults, projectToolView, objectShapeKeys, rebuildObject, mergeSchemas, staticInputRounds, validateMcpRoundPolicy, validateResolvedInputRounds, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, declaresDraft07, withDefsDialect, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };

package/dist/{index-sr93cwf9.js → index-e2z3ahw9.js}

@@ -5,7 +5,7 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-cxqhvq21.js";
+} from "./index-xnj9bgxe.js";
 import {
   base64UrlToBytes,
   bytesToBase64Url
@@ -20,7 +20,7 @@ import {
 } from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/server/middleware/cookies.ts
 function parseCookieHeader(header) {

package/dist/{index-yewwh1w4.js → index-e87kakm4.js}

@@ -1,9 +1,10 @@
 import {
-  DEFAULT_STREAM_LINE_BYTES,
-  inputIsQuery,
-  parseSSE,
-  readBoundedUtf8Lines
-} from "./index-v5573g1k.js";
+  inputIsQuery
+} from "./index-48ffdxgk.js";
+import {
+  ContractStreamFrameSchema,
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES
+} from "./index-wqgjfstn.js";
 import {
   ApiError,
   RequestCancellationError,
@@ -11,17 +12,76 @@ import {
   parseApiErrorBody,
   refuseLocally,
   responseTraceId
-} from "./index-3xwxfj4z.js";
+} from "./index-zeemqhqx.js";
 import {
-  ContractStreamFrameSchema,
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-0a349c33.js";
+} from "./index-gyr48nzg.js";
 import {
   isRecord,
   mapObject,
   typedEntries
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
+
+// src/internal/bounded-lines.ts
+var DEFAULT_STREAM_LINE_BYTES = 1024 * 1024;
+function lineLimit(value) {
+  const resolved = value ?? DEFAULT_STREAM_LINE_BYTES;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+    throw new TypeError("maxLineBytes must be a positive safe integer");
+  }
+  return resolved;
+}
+function joinBytes(left, right) {
+  if (left.byteLength === 0)
+    return right.slice();
+  const result = new Uint8Array(left.byteLength + right.byteLength);
+  result.set(left);
+  result.set(right, left.byteLength);
+  return result;
+}
+async function* readBoundedUtf8Lines(response, maxLineBytes, requireFinalNewline = false) {
+  const reader = response.body?.getReader();
+  if (!reader)
+    return;
+  const limit = lineLimit(maxLineBytes);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let pending = new Uint8Array;
+  try {
+    for (;; ) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      let start = 0;
+      for (let index = 0;index < chunk.value.byteLength; index += 1) {
+        if (chunk.value[index] !== 10)
+          continue;
+        const lineBytes = joinBytes(pending, chunk.value.slice(start, index));
+        if (lineBytes.byteLength > limit) {
+          throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
+        }
+        yield decoder.decode(lineBytes);
+        pending = new Uint8Array;
+        start = index + 1;
+      }
+      pending = joinBytes(pending, chunk.value.slice(start));
+      if (pending.byteLength > limit) {
+        throw new RangeError(`Stream line exceeds the ${limit} byte limit`);
+      }
+    }
+    if (pending.byteLength > 0) {
+      if (requireFinalNewline) {
+        throw new SyntaxError("Stream ended with an unterminated final line");
+      }
+      yield decoder.decode(pending);
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+}
+
 // src/browser/stream.ts
 function parseFailure(raw, error, onParseError) {
   const failure = error instanceof Error ? error : new Error(String(error));
@@ -45,6 +105,31 @@ async function* parseNDJSON(response, options) {
     parseFailure("", error, options?.onParseError);
   }
 }
+async function* parseSSE(response, options) {
+  try {
+    for await (const rawLine of readBoundedUtf8Lines(response, options?.maxLineBytes ?? DEFAULT_STREAM_LINE_BYTES)) {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      if (!line.startsWith("data:"))
+        continue;
+      const data = line.slice(5).replace(/^ /, "");
+      if (data === "[DONE]")
+        return;
+      try {
+        yield JSON.parse(data);
+      } catch (error) {
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!options?.onParseError)
+          throw failure;
+        options.onParseError(data, failure);
+      }
+    }
+  } catch (error) {
+    const failure = error instanceof Error ? error : new Error(String(error));
+    if (!options?.onParseError)
+      throw failure;
+    options.onParseError("", failure);
+  }
+}
 
 // src/browser/client-multipart.ts
 function isFileDescriptor(value) {
@@ -644,4 +729,4 @@ function createScopedUrlBuilders(contracts, source, scopeConfigs) {
   return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
 }
 
-export { parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };
+export { parseNDJSON, parseSSE, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };

package/dist/{index-cby4ar3v.js → index-eqqvgdb3.js}

@@ -1,4 +1,4 @@
-// src/tools/json-schema.ts
+// src/json-schema/json-schema.ts
 import { z } from "zod";
 function toJsonSchema(schema, io, unrepresentable = "throw", target = "draft-2020-12") {
   return z.toJSONSchema(schema, {