stitchkit 0.68.8 → 0.68.10

package/dist/cli.js

@@ -5,16 +5,15 @@ import {
   emitResult,
   parseCliArgs,
   pollUntilDone
-} from "./index-1bmpkhj2.js";
-import"./index-88yyydag.js";
-import"./index-04agqrs8.js";
-import"./index-51a19y3v.js";
+} from "./index-2t6zt5cg.js";
+import"./index-eqqyd9v8.js";
+import"./index-y2ctppmg.js";
+import"./index-f24xg2cw.js";
 import"./index-sbdmyz75.js";
-import"./index-vkk06pv1.js";
-import"./index-6djpbnda.js";
+import"./index-22by16v6.js";
 import"./index-cby4ar3v.js";
-import"./index-bmmtz6r9.js";
-import"./index-smpbdg6k.js";
+import"./index-pgsyp3xh.js";
+import"./index-qyrqwr4c.js";
 import"./index-0w9abg87.js";
 import"./index-6k1937bx.js";
 export {

package/dist/contract/index.js

@@ -20,8 +20,8 @@ import {
   paginatedSchema,
   rateLimited,
   unauthorized
-} from "../index-j2nq04z6.js";
-import"../index-tss6bk5c.js";
+} from "../index-f6n5n7nz.js";
+import"../index-ksp6e2ye.js";
 export {
   ALL_TRANSPORTS,
   AppError,

package/dist/{index-vkk06pv1.js → index-22by16v6.js}

@@ -1,12 +1,9 @@
-import {
-  mergeSchemas
-} from "./index-6djpbnda.js";
 import {
   toJsonSchema
 } from "./index-cby4ar3v.js";
 import {
   isRecord
-} from "./index-smpbdg6k.js";
+} from "./index-qyrqwr4c.js";
 
 // src/tools/portable-formats.ts
 var PORTABLE_JSON_SCHEMA_FORMATS = new Set([
@@ -552,6 +549,57 @@ function findUntypedProperties(schema, prefix = "") {
   return found;
 }
 
+// src/tools/schema.ts
+import { z } from "zod";
+function objectShapeKeys(schema) {
+  return schema instanceof z.ZodObject ? Object.keys(schema.shape) : [];
+}
+function keyPolicyOf(schema) {
+  return schema.def.catchall;
+}
+function rebuildObject(source, shape) {
+  return withKeyPolicy(z.object(shape), keyPolicyOf(source));
+}
+function withKeyPolicy(object, policy) {
+  if (policy === undefined)
+    return object;
+  return object.catchall(representable(policy));
+}
+function representable(policy) {
+  if (policy instanceof z.ZodNever || policy instanceof z.ZodUnknown)
+    return policy;
+  if (!(policy instanceof z.ZodType))
+    return z.unknown();
+  try {
+    toJsonSchema(policy, "input");
+    return policy;
+  } catch {
+    return z.unknown();
+  }
+}
+function mergeSchemas(paramsSchema, inputSchema) {
+  if (paramsSchema && !(paramsSchema instanceof z.ZodObject)) {
+    throw new Error("Tool params schema must be a z.object()");
+  }
+  const paramsObject = paramsSchema instanceof z.ZodObject ? paramsSchema : undefined;
+  if (!inputSchema) {
+    return paramsObject ?? z.object({});
+  }
+  if (inputSchema instanceof z.ZodObject) {
+    if (paramsObject) {
+      const conflicts = Object.keys(paramsObject.shape).filter((key) => (key in inputSchema.shape));
+      if (conflicts.length > 0) {
+        throw new Error(`Schema merge conflict: ${conflicts.join(", ")} appear in both params and input`);
+      }
+    }
+    return rebuildObject(inputSchema, {
+      ...paramsObject?.shape ?? {},
+      ...inputSchema.shape
+    });
+  }
+  return paramsObject ? z.intersection(paramsObject, inputSchema) : inputSchema;
+}
+
 // src/tools/names.ts
 var SINGULAR_EXCEPTIONS = new Set([
   "analytics",
@@ -618,7 +666,7 @@ function assertUniqueToolName(name, taken, surface) {
 }
 
 // src/tools/presentation.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 function withoutDialect(schema) {
   const result = {};
   for (const [key, value] of Object.entries(schema)) {
@@ -712,7 +760,7 @@ function buildToolPresentationSchema(config) {
     };
   }
   if (config.extendSchema) {
-    const extra = namespaceLocalReferences(schemaFromZod(z.object(config.extendSchema), unrepresentable, flatten), "extend");
+    const extra = namespaceLocalReferences(schemaFromZod(z2.object(config.extendSchema), unrepresentable, flatten), "extend");
     if (extra) {
       presentation = mergeObjectSchemas(withoutDialect(extra), withoutDialect(presentation), true);
     }
@@ -733,7 +781,7 @@ function presentationMetadata(schema) {
 }
 
 // src/tools/internal/surface-projector.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/tools/mcp-round-policy.ts
 function validateMcpRoundPolicy(tool, policy, runtime) {
@@ -761,7 +809,7 @@ function validateMcpRoundPolicy(tool, policy, runtime) {
 
 // src/tools/internal/surface-projector.ts
 function assertToolExtensionCompatible(base, extra) {
-  if (!(base instanceof z2.ZodObject))
+  if (!(base instanceof z3.ZodObject))
     return;
   const conflicts = Object.keys(extra).filter((key) => (key in base.shape));
   if (conflicts.length > 0) {
@@ -972,4 +1020,4 @@ function prepareProjectedMcpTools(tools, config = {}) {
   return prepared;
 }
 
-export { validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };
+export { objectShapeKeys, rebuildObject, mergeSchemas, validateMcpRoundPolicy, assertToolName, assertUniqueToolName, PORTABLE_JSON_SCHEMA_FORMATS, findNonPortableFormats, flattenToolJsonSchema, buildToolPresentationSchema, presentationMetadata, findUntypedProperties, assertToolExtensionCompatible, projectRuntimeTool, projectToolSurface, mcpProjectionCandidate, prepareProjectedMcpTools };

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

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

package/dist/{index-1bmpkhj2.js → index-2t6zt5cg.js}

@@ -1,24 +1,20 @@
 import {
-  contractToolMountable,
-  createToolRunner,
-  formatToolError
-} from "./index-88yyydag.js";
+  collectToolSurface
+} from "./index-eqqyd9v8.js";
 import {
   coerceJsonArgs,
+  createToolRunner,
+  formatToolError,
   toolResultFromError
-} from "./index-04agqrs8.js";
+} from "./index-y2ctppmg.js";
 import {
   isWithinDir
 } from "./index-sbdmyz75.js";
 import {
   assertUniqueToolName,
   buildToolPresentationSchema,
-  projectRuntimeTool,
-  projectToolSurface
-} from "./index-vkk06pv1.js";
-import {
   objectShapeKeys
-} from "./index-6djpbnda.js";
+} from "./index-22by16v6.js";
 import {
   jsonSchemaFields
 } from "./index-cby4ar3v.js";
@@ -27,91 +23,10 @@ import {
   isUnsafeKey,
   safeJsonParse,
   validateDeclaredOutput
-} from "./index-bmmtz6r9.js";
+} from "./index-pgsyp3xh.js";
 import {
   isRecord
-} from "./index-smpbdg6k.js";
-
-// src/tools/runtime-tool.ts
-function defineRuntimeTool(definition) {
-  if (definition.transports?.length === 0) {
-    throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
-  }
-  return definition;
-}
-function createRuntimeToolFactory(config) {
-  function parseContext(context) {
-    const parsed = config.context.parse(context);
-    return {
-      ...context,
-      ...parsed,
-      params: undefined,
-      input: context.input,
-      ...context.mcp !== undefined && { mcp: context.mcp }
-    };
-  }
-  function define(definition) {
-    if (definition.output !== undefined) {
-      const { action: action2, method: method2, meta: meta2, handler: handler2, ...tool2 } = definition;
-      const identity2 = {
-        serviceName: config.serviceName,
-        action: action2,
-        method: method2,
-        ...config.scope !== undefined && { scope: config.scope },
-        ...(meta2 ?? config.meta) !== undefined && { meta: meta2 ?? config.meta }
-      };
-      return defineRuntimeTool({
-        ...tool2,
-        identity: identity2,
-        handler: (context) => handler2(parseContext(context))
-      });
-    }
-    const { action, method, meta, handler, ...tool } = definition;
-    const identity = {
-      serviceName: config.serviceName,
-      action,
-      method,
-      ...config.scope !== undefined && { scope: config.scope },
-      ...(meta ?? config.meta) !== undefined && { meta: meta ?? config.meta }
-    };
-    return defineRuntimeTool({
-      ...tool,
-      identity,
-      handler: (context) => handler(parseContext(context))
-    });
-  }
-  return { define };
-}
-function runtimeToolIdentity(definition) {
-  return {
-    method: definition.identity.method,
-    desc: definition.description,
-    serviceName: definition.identity.serviceName,
-    key: definition.identity.action,
-    toolName: definition.name,
-    scope: definition.identity.scope,
-    meta: definition.identity.meta,
-    annotations: definition.annotations,
-    ui: definition.ui,
-    mcp: definition.mcp
-  };
-}
-function runtimeToolMountable(definition, assertName = true) {
-  const projected = projectRuntimeTool(definition, assertName);
-  const method = {
-    ...runtimeToolIdentity(definition),
-    inputSchema: definition.input,
-    outputSchema: definition.output,
-    handler: definition.handler
-  };
-  return {
-    method,
-    name: projected.name,
-    argumentSchema: definition.input,
-    presentationSchema: projected.presentationSchema,
-    shouldExtend: false
-  };
-}
+} from "./index-qyrqwr4c.js";
 
 // src/tools/cli-args.ts
 import { z } from "zod";
@@ -1193,46 +1108,6 @@ function assertCliPoliciesResolved(commands, config) {
   }
 }
 
-// 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;
-}
-
 // src/tools/cli.ts
 var GLOBAL_OPTIONS = [
   ["--json", "Emit compact success/error JSON records (for scripts)"],
@@ -1674,4 +1549,4 @@ async function createCli(config) {
   return exit(downloadsOk ? exitCode : 1);
 }
 
-export { defineRuntimeTool, createRuntimeToolFactory, collectToolSurface, WaitTimeoutError, runWaitOperation, fetchGuarded, fetchPinnedDocument, readCapped, parseCliArgs, defineCliCommand, DEFAULT_EXIT_CODES, emitResult, pollUntilDone, createCli };
+export { WaitTimeoutError, runWaitOperation, fetchGuarded, fetchPinnedDocument, readCapped, parseCliArgs, defineCliCommand, DEFAULT_EXIT_CODES, emitResult, pollUntilDone, createCli };

package/dist/index-bt5179zb.js

@@ -0,0 +1,99 @@
+import {
+  collectToolSurface
+} from "./index-eqqyd9v8.js";
+import {
+  createToolRunner,
+  formatToolError,
+  isToolExecutionControlError,
+  toolResultFromError
+} from "./index-y2ctppmg.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
+
+// src/tools/agent.ts
+import { jsonSchema, tool } from "ai";
+function mountAgent(services, config = {}) {
+  const serviceList = Array.isArray(services) ? services : [services];
+  const tools = {};
+  const runTool = createToolRunner({
+    source: "agent",
+    extend: config.extend,
+    context: config.context,
+    hooks: config.hooks,
+    lifecycle: config.lifecycle,
+    errorHint: config.errorHint,
+    coerceJsonArgs: config.coerceJsonArgs,
+    onOutputStrip: config.onOutputStrip
+  });
+  for (const entry of collectToolSurface({
+    surface: { services: serviceList, runtimeTools: config.runtimeTools },
+    transport: "AGENT",
+    extend: config.extend,
+    flattenUnionInput: config.flattenUnionInput
+  })) {
+    const { mountable } = entry;
+    const inputSchema = jsonSchema(mountable.presentationSchema, {
+      validate: async (value) => isRecord(value) ? { success: true, value } : { success: false, error: new Error("Tool arguments must be an object") }
+    });
+    const execute = async (rawArgs, options) => {
+      const args = isRecord(rawArgs) ? rawArgs : {};
+      try {
+        const result = await runTool(mountable, args, { signal: options.abortSignal });
+        if (result.ok)
+          return result.data;
+        return formatToolError(result, mountable.name, config.errorHint);
+      } catch (err) {
+        if (isToolExecutionControlError(err))
+          throw err;
+        return formatToolError(toolResultFromError(err), mountable.name, config.errorHint);
+      }
+    };
+    const presenter = entry.kind === "runtime" ? entry.definition.present?.agent : undefined;
+    if (entry.kind === "runtime" && presenter) {
+      const { definition } = entry;
+      const output = definition.output;
+      if (!output) {
+        throw new Error(`Runtime tool "${definition.name}" presenter requires an output schema`);
+      }
+      tools[definition.name] = tool({
+        description: definition.description,
+        inputSchema,
+        outputSchema: output,
+        execute,
+        toModelOutput: async ({ output: rawOutput }) => {
+          const parsed = output.safeParse(rawOutput);
+          if (!parsed.success) {
+            return { type: "text", value: JSON.stringify(rawOutput) };
+          }
+          return presenter(parsed.data);
+        }
+      });
+    } else {
+      const output = entry.kind === "runtime" ? entry.definition.output : undefined;
+      tools[mountable.name] = tool({
+        description: mountable.method.desc,
+        inputSchema,
+        ...output && { outputSchema: output },
+        execute
+      });
+    }
+  }
+  return tools;
+}
+
+// src/tools/manifest.ts
+function buildToolManifest(config) {
+  return collectToolSurface({
+    surface: config,
+    transport: config.transport,
+    extend: config.extend,
+    flattenUnionInput: config.flattenUnionInput
+  }).map(({ mountable }) => ({
+    name: mountable.name,
+    description: mountable.method.desc,
+    inputSchema: mountable.presentationSchema
+  }));
+}
+
+export { mountAgent, buildToolManifest };

package/dist/index-eqqyd9v8.js

@@ -0,0 +1,130 @@
+import {
+  contractToolMountable
+} from "./index-y2ctppmg.js";
+import {
+  projectRuntimeTool,
+  projectToolSurface
+} from "./index-22by16v6.js";
+
+// src/tools/runtime-tool.ts
+function defineRuntimeTool(definition) {
+  if (definition.transports?.length === 0) {
+    throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
+  }
+  return definition;
+}
+function createRuntimeToolFactory(config) {
+  function parseContext(context) {
+    const parsed = config.context.parse(context);
+    return {
+      ...context,
+      ...parsed,
+      params: undefined,
+      input: context.input,
+      ...context.mcp !== undefined && { mcp: context.mcp }
+    };
+  }
+  function define(definition) {
+    if (definition.output !== undefined) {
+      const { action: action2, method: method2, meta: meta2, handler: handler2, ...tool2 } = definition;
+      const identity2 = {
+        serviceName: config.serviceName,
+        action: action2,
+        method: method2,
+        ...config.scope !== undefined && { scope: config.scope },
+        ...(meta2 ?? config.meta) !== undefined && { meta: meta2 ?? config.meta }
+      };
+      return defineRuntimeTool({
+        ...tool2,
+        identity: identity2,
+        handler: (context) => handler2(parseContext(context))
+      });
+    }
+    const { action, method, meta, handler, ...tool } = definition;
+    const identity = {
+      serviceName: config.serviceName,
+      action,
+      method,
+      ...config.scope !== undefined && { scope: config.scope },
+      ...(meta ?? config.meta) !== undefined && { meta: meta ?? config.meta }
+    };
+    return defineRuntimeTool({
+      ...tool,
+      identity,
+      handler: (context) => handler(parseContext(context))
+    });
+  }
+  return { define };
+}
+function runtimeToolIdentity(definition) {
+  return {
+    method: definition.identity.method,
+    desc: definition.description,
+    serviceName: definition.identity.serviceName,
+    key: definition.identity.action,
+    toolName: definition.name,
+    scope: definition.identity.scope,
+    meta: definition.identity.meta,
+    annotations: definition.annotations,
+    ui: definition.ui,
+    mcp: definition.mcp
+  };
+}
+function runtimeToolMountable(definition, assertName = true) {
+  const projected = projectRuntimeTool(definition, assertName);
+  const method = {
+    ...runtimeToolIdentity(definition),
+    inputSchema: definition.input,
+    outputSchema: definition.output,
+    handler: definition.handler
+  };
+  return {
+    method,
+    name: projected.name,
+    argumentSchema: definition.input,
+    presentationSchema: projected.presentationSchema,
+    shouldExtend: false
+  };
+}
+
+// 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 };

package/dist/{index-51a19y3v.js → index-f24xg2cw.js}

@@ -1,10 +1,10 @@
 import {
   isUnsafeKey,
   resolveTraceContext
-} from "./index-bmmtz6r9.js";
+} from "./index-pgsyp3xh.js";
 import {
   isRecord
-} from "./index-smpbdg6k.js";
+} from "./index-qyrqwr4c.js";
 
 // src/server/request.ts
 function generateTraceId() {

package/dist/{index-j2nq04z6.js → index-f6n5n7nz.js}

@@ -1,6 +1,6 @@
 import {
   mapObjectTypeBoundary
-} from "./index-tss6bk5c.js";
+} from "./index-ksp6e2ye.js";
 
 // src/contract/define.ts
 import { z } from "zod";

package/dist/{index-9t2tdk1x.js → index-grgvpbch.js}

@@ -1,13 +1,11 @@
 import {
   collectTools,
-  createToolRunner
-} from "./index-88yyydag.js";
-import {
+  createToolRunner,
   toolErrorFromResult
-} from "./index-04agqrs8.js";
+} from "./index-y2ctppmg.js";
 import {
   assertUniqueToolName
-} from "./index-vkk06pv1.js";
+} from "./index-22by16v6.js";
 import {
   AppError
 } from "./index-0w9abg87.js";

package/dist/{index-n34x0q5e.js → index-hb0mncmj.js}

@@ -3,17 +3,17 @@ import {
   inputIsQuery,
   parseSSE,
   readBoundedUtf8Lines
-} from "./index-r5s4wqb5.js";
+} from "./index-t23p2b68.js";
 import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-bmmtz6r9.js";
+} from "./index-pgsyp3xh.js";
 import {
   isRecord,
   mapObject,
   typedEntries
-} from "./index-smpbdg6k.js";
+} from "./index-qyrqwr4c.js";
 
 // src/browser/cancellation.ts
 class RequestCancellationError extends Error {

package/dist/{index-6tqys26z.js → index-hcx9yypn.js}

@@ -7,7 +7,7 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-z575awm9.js";
+} from "./index-hxh98zbm.js";
 import {
   extractIp,
   getClientInfo,
@@ -18,7 +18,7 @@ import {
   runWithRequestContext,
   setRequestEndpoint,
   setRequestError
-} from "./index-51a19y3v.js";
+} from "./index-f24xg2cw.js";
 import {
   ShutdownOptionsSchema
 } from "./index-dk6e56g0.js";
@@ -34,11 +34,11 @@ import {
   safeJsonParse,
   validateDeclaredOutput,
   zodIssues
-} from "./index-bmmtz6r9.js";
+} from "./index-pgsyp3xh.js";
 import {
   isRecord,
   transportResult
-} from "./index-smpbdg6k.js";
+} from "./index-qyrqwr4c.js";
 import {
   AppError,
   badRequest

package/dist/{index-z575awm9.js → index-hxh98zbm.js}

@@ -1,13 +1,13 @@
 import {
   isUnsafeKey,
   mergeMeta
-} from "./index-bmmtz6r9.js";
+} from "./index-pgsyp3xh.js";
 import {
   callRuntimeHandler,
   isRecord,
   transportResult,
   typedEntries
-} from "./index-smpbdg6k.js";
+} from "./index-qyrqwr4c.js";
 
 // src/server/middleware/cors.ts
 var DEFAULT_CORS_ALLOW_HEADERS = "Content-Type, Authorization, X-Trace-Id, traceparent, tracestate";

package/dist/{index-bmmtz6r9.js → index-pgsyp3xh.js}

@@ -1,6 +1,6 @@
 import {
   isRecord
-} from "./index-smpbdg6k.js";
+} from "./index-qyrqwr4c.js";
 import {
   AppError
 } from "./index-0w9abg87.js";