stitchkit 0.68.11 → 0.70.0

package/dist/{index-hqza5nde.js → index-hsabxjz0.js}

@@ -1,3 +1,6 @@
+import {
+  assistantStatus
+} from "./index-es0h4w26.js";
 import {
   AgentMessageSchema,
   AgentRecordIdSchema,
@@ -7,21 +10,39 @@ import {
   AgentTerminalReasonSchema,
   AgentUsageSchema,
   runStateForTerminalReason
-} from "./index-ysphyxax.js";
+} from "./index-x1th9s8c.js";
 
-// src/agent-runtime/store.ts
+// src/agent-runtime/conversations.ts
 import { z } from "zod";
-var AgentStoreConflictSchema = z.object({
-  outcome: z.literal("conflict"),
+var AgentConversationSummarySchema = z.object({
+  conversationId: AgentRecordIdSchema,
+  version: AgentRecordVersionSchema,
+  updatedAt: z.iso.datetime({ offset: true }),
+  preview: z.string(),
+  activeRuns: z.int().nonnegative()
+}).strict();
+var AgentConversationPageSchema = z.object({
+  items: z.array(AgentConversationSummarySchema),
+  nextCursor: z.string().min(1).optional()
+}).strict();
+var AgentConversationMessagePageSchema = z.object({
+  items: z.array(AgentMessageSchema),
+  nextCursor: z.string().min(1).optional()
+}).strict();
+
+// src/agent-runtime/store.ts
+import { z as z2 } from "zod";
+var AgentStoreConflictSchema = z2.object({
+  outcome: z2.literal("conflict"),
   actualVersion: AgentRecordVersionSchema
 });
-var AgentStoreNotFoundSchema = z.object({ outcome: z.literal("not_found") });
-var AgentStoreAppliedSchema = z.object({
-  outcome: z.literal("applied"),
+var AgentStoreNotFoundSchema = z2.object({ outcome: z2.literal("not_found") });
+var AgentStoreAppliedSchema = z2.object({
+  outcome: z2.literal("applied"),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreDuplicateSchema = z.object({
-  outcome: z.literal("duplicate"),
+var AgentStoreDuplicateSchema = z2.object({
+  outcome: z2.literal("duplicate"),
   input: AgentMessageSchema,
   inputMessageId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
@@ -30,136 +51,116 @@ var AgentStoreDuplicateSchema = z.object({
   assistant: AgentMessageSchema.optional(),
   snapshot: AgentSnapshotSchema
 });
-var AgentStoreMutationResultSchema = z.discriminatedUnion("outcome", [
+var AgentStoreMutationResultSchema = z2.discriminatedUnion("outcome", [
   AgentStoreAppliedSchema,
   AgentStoreDuplicateSchema,
   AgentStoreConflictSchema,
   AgentStoreNotFoundSchema
 ]);
-var AgentRunViewSchema = z.object({
+var AgentRunViewSchema = z2.object({
   snapshotVersion: AgentRecordVersionSchema,
   run: AgentRunSchema,
   assistant: AgentMessageSchema.optional()
 });
-var AcceptInputAndAssignRunSchema = z.object({
-  idempotencyKey: z.string().min(1),
+var AcceptInputAndAssignRunSchema = z2.object({
+  idempotencyKey: z2.string().min(1),
   expectedVersion: AgentRecordVersionSchema.optional(),
   input: AgentMessageSchema,
   run: AgentRunSchema,
   coalesceIntoRunId: AgentRecordIdSchema.optional()
 });
-var AcquireAgentRunSchema = z.object({
+var AcquireAgentRunSchema = z2.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z.string().min(1)
+  ownerId: z2.string().min(1)
 });
-var CheckpointRunAssistantSchema = z.object({
+var CheckpointRunAssistantSchema = z2.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z.string().min(1),
+  ownerId: z2.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   usage: AgentUsageSchema.optional()
 });
-var CommitRunTerminalSchema = z.object({
+var CommitRunTerminalSchema = z2.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  ownerId: z.string().min(1),
+  ownerId: z2.string().min(1),
   fencingToken: AgentRecordVersionSchema.optional(),
   assistant: AgentMessageSchema,
   reason: AgentTerminalReasonSchema,
-  policyName: z.string().min(1).optional(),
+  policyName: z2.string().min(1).optional(),
   usage: AgentUsageSchema.optional(),
-  absorb: z.array(z.object({
+  absorb: z2.array(z2.object({
     runId: AgentRecordIdSchema,
-    inputMessageIds: z.array(AgentRecordIdSchema).min(1)
+    inputMessageIds: z2.array(AgentRecordIdSchema).min(1)
   })).min(1).optional()
 });
-var RequestRunInterruptSchema = z.object({
+var RequestRunInterruptSchema = z2.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema
 });
-var RecoverAgentRunSchema = z.object({
+var RecoverAgentRunSchema = z2.object({
   conversationId: AgentRecordIdSchema,
   runId: AgentRecordIdSchema,
   expectedRevision: AgentRecordVersionSchema,
-  action: z.enum(["requeue", "abandon"]),
-  replaySafe: z.boolean().optional()
+  action: z2.enum(["requeue", "abandon"]),
+  replaySafe: z2.boolean().optional()
 });
-var ReplaceCompactedRangeSchema = z.object({
+var ReplaceCompactedRangeSchema = z2.object({
   conversationId: AgentRecordIdSchema,
   expectedVersion: AgentRecordVersionSchema,
-  replacedMessageIds: z.array(AgentRecordIdSchema).min(1),
+  replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
   summary: AgentMessageSchema
 });
+var AgentRecoverableDescriptorSchema = z2.object({
+  conversationId: AgentRecordIdSchema,
+  run: AgentRunSchema
+});
+var AgentRecoverablePageSchema = z2.object({
+  items: z2.array(AgentRecoverableDescriptorSchema),
+  nextCursor: z2.string().min(1).optional()
+});
 
 // src/agent-runtime/store-driver.ts
-import { z as z2 } from "zod";
-
-// src/agent-runtime/terminal-status.ts
-function isSpeakableAssistantStatus(status) {
-  return status === "completed" || status === "interrupted" || status === "committed";
-}
-function assistantStatus(reason) {
-  if (reason === "success" || reason === "policy_stop" || reason === "provider_stop") {
-    return "completed";
-  }
-  if (reason === "superseded")
-    return "superseded";
-  if (reason === "absorbed")
-    return "superseded";
-  if (reason === "interrupted" || reason === "cancelled" || reason === "shutdown") {
-    return "interrupted";
-  }
-  return "failed";
-}
-
-// src/agent-runtime/store-driver.ts
-var AgentRuntimeHeadSchema = z2.object({
-  schemaVersion: z2.literal(1),
+import { z as z3 } from "zod";
+var AgentRuntimeHeadSchema = z3.object({
+  schemaVersion: z3.literal(1),
   conversationId: AgentRecordIdSchema,
   version: AgentRecordVersionSchema
 });
-var AgentStoredRunSchema = z2.object({
-  schemaVersion: z2.literal(1),
+var AgentStoredRunSchema = z3.object({
+  schemaVersion: z3.literal(1),
   run: AgentRunSchema,
   terminalAssistant: AgentMessageSchema.optional()
 });
-var AgentAdmissionReceiptSchema = z2.object({
-  schemaVersion: z2.literal(1),
+var AgentAdmissionReceiptSchema = z3.object({
+  schemaVersion: z3.literal(1),
   conversationId: AgentRecordIdSchema,
-  idempotencyKey: z2.string().min(1),
+  idempotencyKey: z3.string().min(1),
   input: AgentMessageSchema,
   runId: AgentRecordIdSchema,
   assistantMessageId: AgentRecordIdSchema
 });
-var AgentHistoryMutationSchema = z2.discriminatedUnion("type", [
-  z2.object({ type: z2.literal("admit"), input: AgentMessageSchema }),
-  z2.object({
-    type: z2.literal("upsert-assistant"),
+var AgentHistoryMutationSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("admit"), input: AgentMessageSchema }),
+  z3.object({
+    type: z3.literal("upsert-assistant"),
     message: AgentMessageSchema
   }),
-  z2.object({
-    type: z2.literal("replace-compacted-range"),
-    replacedMessageIds: z2.array(AgentRecordIdSchema).min(1),
+  z3.object({
+    type: z3.literal("replace-compacted-range"),
+    replacedMessageIds: z3.array(AgentRecordIdSchema).min(1),
     summary: AgentMessageSchema
   })
 ]);
-var AgentRecoverableDescriptorSchema = z2.object({
-  conversationId: AgentRecordIdSchema,
-  run: AgentRunSchema
-});
-var AgentRecoverablePageSchema = z2.object({
-  items: z2.array(AgentRecoverableDescriptorSchema),
-  nextCursor: z2.string().min(1).optional()
-});
-var AgentRecoverableScanInputSchema = z2.object({
-  cursor: z2.string().min(1).optional(),
-  limit: z2.number().int().min(1).max(1000)
+var AgentRecoverableScanInputSchema = z3.object({
+  cursor: z3.string().min(1).optional(),
+  limit: z3.number().int().min(1).max(1000)
 });
 function emptyHead(conversationId) {
   return AgentRuntimeHeadSchema.parse({
@@ -263,7 +264,7 @@ function validateSnapshot(head, messages, records) {
     }
   }
 }
-var RecoverableCursorSchema = z2.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
+var RecoverableCursorSchema = z3.tuple([AgentRecordIdSchema, AgentRecordIdSchema]);
 function recoverableCursor(input) {
   return JSON.stringify([input.conversationId, input.run.id]);
 }
@@ -313,7 +314,7 @@ function reduceStore(current, operation) {
     if (input.coalesceIntoRunId !== undefined && (!coalescedRun || coalescedRun.conversationId !== input.input.conversationId || coalescedRun.state !== "queued" || coalescedRun.ownerId !== undefined || coalescedRun.terminalReason !== undefined)) {
       return coalescedRun ? conflict(coalescedRun.revision) : { outcome: "not_found" };
     }
-    if (input.run.conversationId !== input.input.conversationId || input.run.inputMessageIds.length !== 1 || input.run.inputMessageIds[0] !== input.input.id || input.run.state !== "queued" || input.run.revision !== 0 || input.run.executionSequence !== undefined || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" || input.input.status !== "committed" || input.input.runId !== undefined || current.messages.some((message) => message.id === input.input.id) || coalescedRun !== undefined && input.input.id === coalescedRun.assistantMessageId || !coalescedRun && (input.run.assistantMessageId === input.input.id || current.runs.some((candidate) => candidate.id === input.run.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.run.assistantMessageId) || current.messages.some((message) => message.id === input.run.assistantMessageId))) {
+    if (input.run.conversationId !== input.input.conversationId || input.run.inputMessageIds.length !== 1 || input.run.inputMessageIds[0] !== input.input.id || input.run.state !== "queued" || input.run.revision !== 0 || input.run.executionSequence !== undefined || input.run.ownerId !== undefined || input.run.terminalReason !== undefined || input.run.terminalPolicyName !== undefined || input.input.role !== "user" && input.input.role !== "tool" || input.input.status !== "committed" || input.input.runId !== undefined || current.messages.some((message) => message.id === input.input.id) || coalescedRun !== undefined && input.input.id === coalescedRun.assistantMessageId || !coalescedRun && (input.run.assistantMessageId === input.input.id || current.runs.some((candidate) => candidate.id === input.run.id) || current.runs.some((candidate) => candidate.assistantMessageId === input.run.assistantMessageId) || current.messages.some((message) => message.id === input.run.assistantMessageId))) {
       throw new TypeError("Input and queued run do not form one valid assignment");
     }
     const assignedRun = coalescedRun ? AgentRunSchema.parse({
@@ -911,4 +912,4 @@ function createMemoryAgentRuntimeStore() {
   return createAgentRuntimeStore(driver);
 }
 
-export { isSpeakableAssistantStatus, assistantStatus, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };
+export { AgentConversationSummarySchema, AgentConversationPageSchema, AgentConversationMessagePageSchema, AgentStoreConflictSchema, AgentStoreNotFoundSchema, AgentStoreAppliedSchema, AgentStoreDuplicateSchema, AgentStoreMutationResultSchema, AgentRunViewSchema, AcceptInputAndAssignRunSchema, AcquireAgentRunSchema, CheckpointRunAssistantSchema, CommitRunTerminalSchema, RequestRunInterruptSchema, RecoverAgentRunSchema, ReplaceCompactedRangeSchema, AgentRecoverableDescriptorSchema, AgentRecoverablePageSchema, AgentRuntimeHeadSchema, AgentStoredRunSchema, AgentAdmissionReceiptSchema, AgentHistoryMutationSchema, ACTIVE_AGENT_RUN_STATES, createAgentRuntimeStore, createMemoryAgentRuntimeStore };

package/dist/{index-f24xg2cw.js → index-ktsps64f.js}

@@ -1,7 +1,9 @@
 import {
-  isUnsafeKey,
   resolveTraceContext
-} from "./index-pgsyp3xh.js";
+} from "./index-bd17ytae.js";
+import {
+  isUnsafeKey
+} from "./index-vj3vvpaa.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

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

@@ -1,12 +1,14 @@
 import {
   collectToolSurface
-} from "./index-eqqyd9v8.js";
+} from "./index-vc498pst.js";
 import {
-  coerceJsonArgs,
   createToolRunner,
-  formatToolError,
+  formatToolError
+} from "./index-7rey2b8s.js";
+import {
+  coerceJsonArgs,
   toolResultFromError
-} from "./index-y2ctppmg.js";
+} from "./index-qzbg46b6.js";
 import {
   isWithinDir
 } from "./index-sbdmyz75.js";
@@ -20,10 +22,12 @@ import {
 } from "./index-cby4ar3v.js";
 import {
   formatZodError,
-  isUnsafeKey,
-  safeJsonParse,
   validateDeclaredOutput
-} from "./index-pgsyp3xh.js";
+} from "./index-bd17ytae.js";
+import {
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-vj3vvpaa.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";

package/dist/{index-y2ctppmg.js → index-qzbg46b6.js}

@@ -1,29 +1,27 @@
 import {
   getRequestContext,
   runWithRequestContext
-} from "./index-f24xg2cw.js";
+} from "./index-ktsps64f.js";
 import {
-  assertToolExtensionCompatible,
-  mergeSchemas,
-  objectShapeKeys,
-  projectToolSurface,
-  rebuildObject
+  objectShapeKeys
 } from "./index-22by16v6.js";
 import {
   formatZodError,
-  isUnsafeKey,
   normalizeError,
-  safeJsonParse,
   validateDeclaredOutput
-} from "./index-pgsyp3xh.js";
+} from "./index-bd17ytae.js";
 import {
-  isRecord
-} from "./index-qyrqwr4c.js";
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-vj3vvpaa.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,
   isStitchErrorCode
 } from "./index-0w9abg87.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
 
 // src/tools/coerce.ts
 import { z } from "zod";
@@ -339,66 +337,4 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
   }
 }
 
-// src/tools/mount.ts
-import { z as z2 } from "zod";
-function applyExtend(base, extra) {
-  if (base instanceof z2.ZodObject) {
-    assertToolExtensionCompatible(base, extra);
-    return rebuildObject(base, { ...extra, ...base.shape });
-  }
-  return z2.intersection(z2.object(extra), base);
-}
-function contractToolMountable(projected, extend) {
-  const method = projected.source;
-  const baseArgumentSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
-  const argumentSchema = projected.shouldExtend && extend ? applyExtend(baseArgumentSchema, extend.schema) : baseArgumentSchema;
-  return {
-    method,
-    name: projected.name,
-    argumentSchema,
-    presentationSchema: projected.presentationSchema,
-    shouldExtend: projected.shouldExtend
-  };
-}
-function collectTools(service, transport, config = {}) {
-  const { extend, flattenUnionInput = false, assertNames = true } = config;
-  const tools = [];
-  for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
-    extend,
-    flattenUnionInput,
-    assertNames,
-    assertUniqueNames: false
-  })) {
-    if (projected.kind !== "contract")
-      continue;
-    tools.push(contractToolMountable(projected, extend));
-  }
-  return tools;
-}
-function createToolRunner(config) {
-  const extension = config.extend ? {
-    schema: z2.object(config.extend.schema),
-    resolve: config.extend.resolve
-  } : undefined;
-  return async function runOneToolCall(tool, rawArgs, context) {
-    return executeToolMethod(tool.method, tool.name, rawArgs, { ...config.context, ...context, source: config.source }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(tool.name, paths) : undefined, tool.shouldExtend ? extension : undefined);
-  };
-}
-function formatToolError(result, toolName, errorHint) {
-  const err = { error: result.code };
-  if (result.details)
-    err.details = result.details;
-  const hints = [];
-  if (result.hint)
-    hints.push(result.hint);
-  if (errorHint && toolName) {
-    const global = errorHint(toolName, result.code);
-    if (global)
-      hints.push(global);
-  }
-  if (hints.length > 0)
-    err._hint = hints.join(" ");
-  return err;
-}
-
-export { coerceJsonArgs, ToolExecutionControlError, isToolExecutionControlError, toolResultFromError, toolErrorFromResult, executeToolMethod, contractToolMountable, collectTools, createToolRunner, formatToolError };
+export { coerceJsonArgs, ToolExecutionControlError, isToolExecutionControlError, toolResultFromError, toolErrorFromResult, executeToolMethod };

package/dist/{index-bt5179zb.js → index-s8nt8c22.js}

@@ -1,12 +1,17 @@
+import {
+  AgentToolError
+} from "./index-3xnq72rz.js";
 import {
   collectToolSurface
-} from "./index-eqqyd9v8.js";
+} from "./index-vc498pst.js";
 import {
   createToolRunner,
-  formatToolError,
+  formatToolError
+} from "./index-7rey2b8s.js";
+import {
   isToolExecutionControlError,
   toolResultFromError
-} from "./index-y2ctppmg.js";
+} from "./index-qzbg46b6.js";
 import {
   isRecord
 } from "./index-qyrqwr4c.js";
@@ -38,16 +43,16 @@ function mountAgent(services, config = {}) {
     });
     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) {
+      const result = await runTool(mountable, args, {
+        signal: options.abortSignal
+      }).catch((err) => {
         if (isToolExecutionControlError(err))
           throw err;
-        return formatToolError(toolResultFromError(err), mountable.name, config.errorHint);
-      }
+        throw new AgentToolError(formatToolError(toolResultFromError(err), mountable.name, config.errorHint), err);
+      });
+      if (result.ok)
+        return result.data;
+      throw new AgentToolError(formatToolError(result, mountable.name, config.errorHint));
     };
     const presenter = entry.kind === "runtime" ? entry.definition.present?.agent : undefined;
     if (entry.kind === "runtime" && presenter) {

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-hxh98zbm.js → index-vbf2p6me.js}

@@ -1,7 +1,7 @@
 import {
   isUnsafeKey,
   mergeMeta
-} from "./index-pgsyp3xh.js";
+} from "./index-vj3vvpaa.js";
 import {
   callRuntimeHandler,
   isRecord,

package/dist/index-vc498pst.js

@@ -0,0 +1,51 @@
+import {
+  runtimeToolMountable
+} from "./index-wwst0td5.js";
+import {
+  contractToolMountable
+} from "./index-7rey2b8s.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 };