@modainteract/moda-interact-shared 0.13.0 → 0.14.0

package/dist/{chunk-QNANS4R4.js → chunk-GLNBHQKH.js}

@@ -218,41 +218,125 @@ var boundedJson = (bytes) => z2.unknown().refine((v) => {
   }
 });
 
-// src/commerce/definitions.ts
+// src/commerce/external.ts
 import { z as z3 } from "zod";
+var utf8 = (value, maximum) => new TextEncoder().encode(value).length <= maximum;
+var scalar = z3.union([z3.string().refine((value) => utf8(value, 2048)), z3.number().finite(), z3.boolean()]);
+var scalarOrNull = z3.union([scalar, z3.null()]);
+var record = (item, max) => z3.record(z3.string().refine(safeName), item).refine((value) => Object.keys(value).length <= max);
+var ExternalQueryMappingSchema = z3.union([
+  z3.strictObject({ input: z3.string().refine(safeName), omitIfMissing: z3.literal(true).optional() }),
+  z3.strictObject({ literal: scalar })
+]);
+var ExternalQueryMappingsSchema = record(ExternalQueryMappingSchema, 32).superRefine((value, ctx) => {
+  const reserved = /^(authorization|cookie|set-cookie|host|x-api-key|api_key|apikey|access_token|token|secret|password)$/i;
+  for (const key of Object.keys(value)) if (reserved.test(key)) ctx.addIssue({ code: "custom", path: [key], message: "Reserved query key" });
+});
+var ExternalPathSchema = z3.string().max(1024).refine(
+  (value) => utf8(value, 1024) && /^\/(?:[A-Za-z0-9._~-]+\/)*[A-Za-z0-9._~-]*\/?$/.test(value) && !value.includes("//") && !value.includes("%") && !value.includes("\\") && !value.includes("?") && !value.includes("#") && !value.includes("{") && !value.includes("}")
+);
+var mediaType = z3.string().min(1).max(128).refine((value) => value === value.toLowerCase() && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(value));
+var ExternalResponseFormatSchema = z3.strictObject({ mode: z3.enum(["JSON", "TEXT"]), mediaTypes: z3.array(mediaType).min(1).max(8).refine((values) => new Set(values).size === values.length) });
+var FieldProjectionSchema = record(z3.strictObject({ path: z3.string().refine(safePath), omitIfMissing: z3.literal(true).optional() }), 32).refine((value) => Object.keys(value).length >= 1);
+var ResponseFilterSchema = z3.discriminatedUnion("op", [
+  z3.strictObject({ path: z3.string().refine(safePath), op: z3.enum(["EQ", "NE", "GT", "GTE", "LT", "LTE", "CONTAINS", "STARTS_WITH"]), value: scalarOrNull }),
+  z3.strictObject({ path: z3.string().refine(safePath), op: z3.literal("IN"), values: z3.array(scalarOrNull).min(1).max(20) })
+]);
+var visualObject = z3.strictObject({ kind: z3.literal("OBJECT"), fields: FieldProjectionSchema });
+var visualList = z3.strictObject({ kind: z3.literal("LIST"), fields: FieldProjectionSchema, filters: z3.array(ResponseFilterSchema).max(8), sort: z3.union([z3.null(), z3.strictObject({ path: z3.string().refine(safePath), direction: z3.enum(["ASC", "DESC"]) })]), limit: z3.int().min(1).max(20) });
+var VisualResponseProcessingSchema = z3.union([visualObject, visualList]);
+var ResponseProcessingSchema = z3.union([VisualResponseProcessingSchema, z3.strictObject({ kind: z3.literal("JAVASCRIPT"), runtimeVersion: z3.literal("quickjs-sync.v1"), source: z3.string().min(1).refine((value) => utf8(value, 16384)) })]);
+var TransformResponseSchema = z3.strictObject({ status: z3.int().min(200).max(299), contentType: z3.string().min(1).max(128), bodyText: z3.string().refine((value) => utf8(value, 262144)), json: z3.union([z3.null(), z3.json()]) });
+var TransformSampleSchema = z3.strictObject({ status: z3.int().min(200).max(299), contentType: z3.string().min(1).max(128), bodyText: z3.string().refine((value) => utf8(value, 262144)) }).refine((value) => jsonBytes(value) <= 524288);
+var ConnectionRevisionViewSchema = z3.strictObject({ id: IdSchema, connectionId: IdSchema, revisionNumber: z3.int().positive(), origin: z3.string().min(1).max(2048), scope: z3.enum(["PLATFORM", "PER_SHOP"]), authMode: z3.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z3.string().min(1).max(128).nullable(), documentation: z3.string().max(16e3), createdAt: z3.iso.datetime({ offset: false }) });
+var ConnectionViewSchema = z3.strictObject({ id: IdSchema, key: z3.string().regex(/^[a-z][a-z0-9_]{0,127}$/), displayName: z3.string().min(1).max(255), description: z3.string().max(4096), enabled: z3.boolean(), editVersion: z3.int().positive(), revisions: z3.array(ConnectionRevisionViewSchema) });
+var CredentialStatusSchema = z3.strictObject({ connectionRevisionId: IdSchema, shopId: IdSchema.nullable(), configured: z3.boolean(), editVersion: z3.int().positive().nullable(), updatedAt: z3.iso.datetime({ offset: false }).nullable() });
+var ConnectionCommandSchema = z3.strictObject({ operationId: IdSchema, reason: z3.string().trim().min(1).max(1e3) });
+var RevisionInputSchema = z3.strictObject({ origin: z3.string().min(1).max(2048), scope: z3.enum(["PLATFORM", "PER_SHOP"]), authMode: z3.enum(["NONE", "BEARER", "API_KEY"]), authHeader: z3.string().min(1).max(128).nullable(), documentation: z3.string().max(16e3) });
+var ConnectionIssueSchema = z3.strictObject({ path: z3.string().max(256), message: z3.string().min(1).max(512) });
+var ConnectionResultSchema = (value) => z3.discriminatedUnion("kind", [
+  z3.strictObject({ kind: z3.literal("ok"), value }),
+  z3.strictObject({ kind: z3.literal("not-found") }),
+  z3.strictObject({ kind: z3.literal("forbidden") }),
+  z3.strictObject({ kind: z3.literal("unavailable") }),
+  z3.strictObject({ kind: z3.literal("invalid"), issues: z3.array(ConnectionIssueSchema).max(32) }),
+  z3.strictObject({ kind: z3.literal("conflict"), code: z3.enum(["STALE_CAS", "CONFLICTING_REPLAY"]) })
+]);
+
+// src/commerce/definitions.ts
+import { z as z4 } from "zod";
 import { gt } from "semver";
-var ToolNameSchema = z3.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
-var ToolBindingSchema = z3.strictObject({
+
+// src/commerce/definition-size.ts
+function definitionStorageBytes(value) {
+  const normalized = JSON.parse(canonicalJson(value));
+  const bytes = (s) => new TextEncoder().encode(s).length;
+  function size(v) {
+    if (typeof v === "number") {
+      const text = JSON.stringify(v);
+      if (!text.includes("e")) return text.length;
+      const [coefficient, exponent] = text.split("e");
+      const sign = coefficient.startsWith("-") ? 1 : 0;
+      const unsigned = coefficient.slice(sign);
+      const digits = unsigned.replace(".", "").length;
+      const point = (unsigned.indexOf(".") < 0 ? unsigned.length : unsigned.indexOf(".")) + Number(exponent);
+      return sign + (point <= 0 ? 2 - point + digits : point >= digits ? point : digits + 1);
+    }
+    if (Array.isArray(v))
+      return 2 + Math.max(0, v.length - 1) * 2 + v.reduce((sum, item) => sum + size(item), 0);
+    if (v && typeof v === "object") {
+      const entries = Object.entries(v);
+      return 2 + Math.max(0, entries.length - 1) * 2 + entries.reduce(
+        (sum, [key, item]) => sum + bytes(JSON.stringify(key)) + 2 + size(item),
+        0
+      );
+    }
+    return bytes(JSON.stringify(v));
+  }
+  return size(normalized);
+}
+var definitionFitsStorage = (value) => {
+  try {
+    return definitionStorageBytes(value) <= 65536;
+  } catch {
+    return false;
+  }
+};
+var DEFINITION_SIZE_MESSAGE = "Definition exceeds the 65536-byte jsonb text limit";
+
+// src/commerce/definitions.ts
+var ToolNameSchema = z4.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
+var ToolBindingSchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema
 });
-var ToolBindingsSchema = z3.array(ToolBindingSchema).max(32).refine((v) => distinct(v.map((x) => x.toolId)));
-var GrantedToolSchema = z3.strictObject({
+var ToolBindingsSchema = z4.array(ToolBindingSchema).max(32).refine((v) => distinct(v.map((x) => x.toolId)));
+var GrantedToolSchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   toolName: ToolNameSchema,
   definitionVersion: SemverSchema,
-  capabilityKeys: z3.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
+  capabilityKeys: z4.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.join("\0") === [...v].sort().join("\0"))
 });
-var GrantedToolsSchema = z3.array(GrantedToolSchema).max(32).refine(
+var GrantedToolsSchema = z4.array(GrantedToolSchema).max(32).refine(
   (v) => distinct(v.map((x) => x.toolId)) && distinct(v.map((x) => x.toolName))
 );
-var ToolDescriptorSchema = z3.strictObject({
+var ToolDescriptorSchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z3.string().min(1).max(4096),
+  description: z4.string().min(1).max(4096),
   inputSchema: InputSchemaSchema
 });
-var MappingSchema = z3.union([
-  z3.strictObject({
-    input: z3.string().refine(safeName),
-    omitIfMissing: z3.literal(true).optional()
+var MappingSchema = z4.union([
+  z4.strictObject({
+    input: z4.string().refine(safeName),
+    omitIfMissing: z4.literal(true).optional()
   }),
-  z3.strictObject({ literal: boundedJson(8192) })
+  z4.strictObject({ literal: boundedJson(8192) })
 ]);
-var MappingsSchema = z3.record(z3.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
+var MappingsSchema = z4.record(z4.string().refine(safeName), MappingSchema).refine((v) => Object.keys(v).length <= 32);
 var POLICY_OPERATIONS = [
   "recovery.getBasket",
   "shopify.searchProducts",
@@ -261,23 +345,41 @@ var POLICY_OPERATIONS = [
   "products.findQualifying",
   "products.findSimilar"
 ];
-var CommerceExecutionSchema = z3.discriminatedUnion("kind", [
-  z3.strictObject({
-    kind: z3.literal("SHOPIFY_STOREFRONT_QUERY"),
-    executorVersion: z3.literal("1.0.0"),
-    apiVersion: z3.literal("2026-07"),
+var ExternalHttpExecutionSchema = z4.strictObject({
+  kind: z4.literal("EXTERNAL_HTTP"),
+  executorVersion: z4.literal("1.0.0"),
+  connectionRevisionId: IdSchema,
+  method: z4.literal("GET"),
+  path: ExternalPathSchema,
+  query: ExternalQueryMappingsSchema,
+  responseFormat: ExternalResponseFormatSchema,
+  resultPath: z4.string().refine((value) => value === "" || safePath(value)),
+  responseProcessing: ResponseProcessingSchema,
+  resultSchema: DetailsSchemaSchema
+}).superRefine((value, ctx) => {
+  if (value.responseProcessing.kind === "JAVASCRIPT" && value.resultPath !== "")
+    ctx.addIssue({ code: "custom", path: ["resultPath"], message: "JAVASCRIPT processing requires an empty resultPath" });
+  if (value.responseProcessing.kind !== "JAVASCRIPT" && value.responseFormat.mode !== "JSON")
+    ctx.addIssue({ code: "custom", path: ["responseFormat", "mode"], message: "Visual processing requires JSON" });
+});
+var CommerceExecutionSchema = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("SHOPIFY_STOREFRONT_QUERY"),
+    executorVersion: z4.literal("1.0.0"),
+    apiVersion: z4.literal("2026-07"),
     schemaHash: HashSchema,
-    document: z3.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
-    operationName: z3.string().refine(safeName),
+    document: z4.string().min(1).refine((v) => new TextEncoder().encode(v).length <= 16384),
+    operationName: z4.string().refine(safeName),
     variables: MappingsSchema,
-    resultPath: z3.string().refine(safePath)
+    resultPath: z4.string().refine(safePath)
   }),
-  z3.strictObject({
-    kind: z3.literal("POLICY_OPERATION"),
-    operation: z3.enum(POLICY_OPERATIONS),
-    operationVersion: z3.literal("1.0.0"),
+  z4.strictObject({
+    kind: z4.literal("POLICY_OPERATION"),
+    operation: z4.enum(POLICY_OPERATIONS),
+    operationVersion: z4.literal("1.0.0"),
     arguments: MappingsSchema
-  })
+  }),
+  ExternalHttpExecutionSchema
 ]);
 function tokensValid(text, root) {
   if (/[<>]/.test(text)) return false;
@@ -287,17 +389,17 @@ function tokensValid(text, root) {
   );
   return !residue.includes("{{") && !residue.includes("}}");
 }
-var fixed = z3.string().max(4096).refine((v) => !/[<>]|\{\{|\}\}/.test(v));
-var ResponseTemplateSchema = z3.discriminatedUnion("kind", [
-  z3.strictObject({
-    kind: z3.literal("text"),
-    text: z3.string().max(4096).refine((v) => tokensValid(v, "result")),
+var fixed = z4.string().max(4096).refine((v) => !/[<>]|\{\{|\}\}/.test(v));
+var ResponseTemplateSchema = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("text"),
+    text: z4.string().max(4096).refine((v) => tokensValid(v, "result")),
     unavailable: fixed
   }),
-  z3.strictObject({
-    kind: z3.literal("items"),
-    itemsPath: z3.string().refine(safePath),
-    item: z3.string().max(4096).refine((v) => tokensValid(v, "item")),
+  z4.strictObject({
+    kind: z4.literal("items"),
+    itemsPath: z4.string().refine(safePath),
+    item: z4.string().max(4096).refine((v) => tokensValid(v, "item")),
     empty: fixed,
     unavailable: fixed
   })
@@ -305,15 +407,15 @@ var ResponseTemplateSchema = z3.discriminatedUnion("kind", [
 var identity = {
   name: ToolNameSchema,
   definitionVersion: SemverSchema,
-  description: z3.string().min(1).max(4096)
+  description: z4.string().min(1).max(4096)
 };
 var forbiddenInput = /^(shopid|customerid|checkoutrecoveryid|conversationid|grantid|releaseid|token|accesstoken|domain|headers|url|graphql|document|authorization)$/i;
-var CommerceToolDefinitionSchema = z3.strictObject({
+var CommerceToolDefinitionSchema = z4.strictObject({
   ...identity,
   inputSchema: InputSchemaSchema,
   execution: CommerceExecutionSchema,
   responseTemplate: ResponseTemplateSchema
-}).superRefine((d, ctx) => {
+}).refine(definitionFitsStorage, { message: DEFINITION_SIZE_MESSAGE }).superRefine((d, ctx) => {
   const properties = d.inputSchema.properties;
   const containsAuthority = (schema) => Object.entries(schema.properties ?? {}).some(
     ([name, child]) => forbiddenInput.test(name) || containsAuthority(child)
@@ -323,7 +425,7 @@ var CommerceToolDefinitionSchema = z3.strictObject({
       code: "custom",
       message: "Authority/credential inputs are forbidden"
     });
-  const mapping = d.execution.kind === "POLICY_OPERATION" ? d.execution.arguments : d.execution.variables;
+  const mapping = d.execution.kind === "POLICY_OPERATION" ? d.execution.arguments : d.execution.kind === "SHOPIFY_STOREFRONT_QUERY" ? d.execution.variables : d.execution.query;
   for (const [name, m] of Object.entries(mapping))
     if ("input" in m && !Object.hasOwn(properties, m.input))
       ctx.addIssue({
@@ -331,16 +433,33 @@ var CommerceToolDefinitionSchema = z3.strictObject({
         path: ["execution", name],
         message: "Unknown mapped input"
       });
+  if (d.execution.kind === "EXTERNAL_HTTP") {
+    for (const [name, mapping2] of Object.entries(d.execution.query))
+      if ("input" in mapping2) {
+        const target = properties[mapping2.input];
+        const type = target && (Array.isArray(target.type) ? target.type[0] : target.type);
+        if (!["string", "integer", "boolean"].includes(type ?? ""))
+          ctx.addIssue({ code: "custom", path: ["execution", "query", name], message: "External mappings require a top-level scalar input" });
+      }
+  }
 });
 var draftObject = boundedJson(65536).refine(
   (v) => !!v && typeof v === "object" && !Array.isArray(v)
 );
-var CommerceToolDraftDefinitionSchema = z3.strictObject({
+var CommerceToolDraftDefinitionSchema = z4.strictObject({
   ...identity,
   inputSchema: draftObject,
   execution: draftObject,
   responseTemplate: draftObject
-}).refine((v) => new TextEncoder().encode(canonicalJson(v)).length <= 131072);
+}).refine(definitionFitsStorage, { message: DEFINITION_SIZE_MESSAGE });
+function externalOutputSchema(execution) {
+  return {
+    type: "object",
+    properties: { values: execution.resultSchema },
+    required: ["values"],
+    additionalProperties: false
+  };
+}
 function at(schema, path) {
   let current = schema;
   for (const part of path.split(".")) current = current?.properties?.[part];
@@ -348,10 +467,7 @@ function at(schema, path) {
 }
 function validateDefinitionForPublication(raw, compiler) {
   const definition = CommerceToolDefinitionSchema.parse(raw);
-  const compiled = compiler.compile(
-    definition.execution,
-    definition.inputSchema
-  );
+  const compiled = definition.execution.kind === "EXTERNAL_HTTP" ? { outputSchema: externalOutputSchema(definition.execution), validateMappedArguments: () => true } : compiler.compile(definition.execution, definition.inputSchema);
   if (!compiled.validateMappedArguments(definition.execution))
     throw new TypeError("Invalid variable/operation mapping");
   const template = definition.responseTemplate;
@@ -376,7 +492,7 @@ function definitionToMcpDescriptor(definition) {
 }
 function mapToolArguments(definition, raw) {
   const input = compileSubset(definition.inputSchema, "input").parse(raw);
-  const mapping = definition.execution.kind === "POLICY_OPERATION" ? definition.execution.arguments : definition.execution.variables;
+  const mapping = definition.execution.kind === "POLICY_OPERATION" ? definition.execution.arguments : definition.execution.kind === "SHOPIFY_STOREFRONT_QUERY" ? definition.execution.variables : definition.execution.query;
   const result = /* @__PURE__ */ Object.create(null);
   for (const [key, m] of Object.entries(mapping)) {
     if ("literal" in m) result[key] = m.literal;
@@ -407,12 +523,12 @@ function validateDefinitionVersion(proposed, highestPublished) {
   SemverSchema.parse(highestPublished);
   return gt(proposed, highestPublished);
 }
-var CommerceToolIdentitySchema = z3.strictObject({
+var CommerceToolIdentitySchema = z4.strictObject({
   id: IdSchema,
   name: ToolNameSchema,
-  enabled: z3.boolean()
+  enabled: z4.boolean()
 });
-var CommerceToolRevisionIdentitySchema = z3.strictObject({
+var CommerceToolRevisionIdentitySchema = z4.strictObject({
   toolId: IdSchema,
   toolRevisionId: IdSchema,
   definitionVersion: SemverSchema,
@@ -423,10 +539,10 @@ var POLICY_OPERATION_DESCRIPTORS = POLICY_OPERATIONS.map(
 );
 
 // src/commerce/response.ts
-import { z as z4 } from "zod";
-var CommerceResponseContractSchema = z4.strictObject({
-  version: z4.literal("response.v1"),
-  instructions: z4.string().min(1).max(8e3),
+import { z as z5 } from "zod";
+var CommerceResponseContractSchema = z5.strictObject({
+  version: z5.literal("response.v1"),
+  instructions: z5.string().min(1).max(8e3),
   detailsSchema: DetailsSchemaSchema
 }).refine((v) => jsonBytes(v) <= 32768);
 var EMPTY_RESPONSE_CONTRACT = {
@@ -439,20 +555,20 @@ var EMPTY_RESPONSE_CONTRACT = {
     additionalProperties: false
   }
 };
-var ReferralReasonSchema = z4.enum([
+var ReferralReasonSchema = z5.enum([
   "INSUFFICIENT_TOOLS",
   "UNVERIFIABLE_FACTS",
   "TOOL_UNAVAILABLE",
   "TOOL_REVOKED"
 ]);
-var CommerceFinalResponseSchema = z4.strictObject({
-  answerKind: z4.enum(["ANSWER", "REFER_TO_STORE"]),
-  replyText: z4.string().min(1).max(4096),
+var CommerceFinalResponseSchema = z5.strictObject({
+  answerKind: z5.enum(["ANSWER", "REFER_TO_STORE"]),
+  replyText: z5.string().min(1).max(4096),
   referralReason: ReferralReasonSchema.nullable(),
   detectedLanguageTag: LanguageSchema.nullable(),
-  detectedLanguageConfidence: z4.number().min(0).max(1).nullable(),
-  evidenceIds: z4.array(IdSchema).max(3).refine((v) => new Set(v).size === v.length),
-  details: z4.record(z4.string(), z4.unknown()).refine((v) => {
+  detectedLanguageConfidence: z5.number().min(0).max(1).nullable(),
+  evidenceIds: z5.array(IdSchema).max(3).refine((v) => new Set(v).size === v.length),
+  details: z5.record(z5.string(), z5.unknown()).refine((v) => {
     try {
       return jsonBytes(v) <= 16384;
     } catch {
@@ -563,22 +679,22 @@ function finalResponseToolSchema(definition) {
 }
 
 // src/commerce/schemas.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { validRange } from "semver";
-var CommerceTurnIdentitySchema = z5.strictObject({
+var CommerceTurnIdentitySchema = z6.strictObject({
   contractVersion: ContractVersionSchema,
   shopId: IdSchema,
   checkoutRecoveryId: IdSchema,
   conversationId: IdSchema,
-  inboundVersion: z5.number().int().positive()
+  inboundVersion: z6.number().int().positive()
 });
-var CommerceConversationGrantSchema = z5.strictObject({
+var CommerceConversationGrantSchema = z6.strictObject({
   id: IdSchema,
   shopId: IdSchema,
   conversationId: IdSchema,
-  initialInboundVersion: z5.number().int().positive(),
+  initialInboundVersion: z6.number().int().positive(),
   releaseId: IdSchema,
-  selectedCapabilityKeys: z5.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.includes("conversation_core")),
+  selectedCapabilityKeys: z6.array(IdSchema).min(1).max(32).refine((v) => distinct(v) && v.includes("conversation_core")),
   grantedTools: GrantedToolsSchema,
   runnerVersion: SemverSchema,
   createdAt: DateSchema,
@@ -591,25 +707,25 @@ var CommerceConversationGrantSchema = z5.strictObject({
   ))
     c.addIssue({ code: "custom", message: "Unselected grant provenance" });
 });
-var CommerceConfigurationSchema = z5.strictObject({
-  maxRecommendations: z5.number().int().min(1).max(3).optional(),
-  maxSearchResults: z5.number().int().min(1).max(20).optional()
+var CommerceConfigurationSchema = z6.strictObject({
+  maxRecommendations: z6.number().int().min(1).max(3).optional(),
+  maxSearchResults: z6.number().int().min(1).max(20).optional()
 });
-var CommerceManifestSchema = z5.strictObject({
+var CommerceManifestSchema = z6.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z5.string().min(1).max(128).refine((v) => !!validRange(v)),
-  capabilities: z5.array(
-    z5.strictObject({
+  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v)),
+  capabilities: z6.array(
+    z6.strictObject({
       key: IdSchema,
       revisionId: IdSchema,
-      position: z5.number().int().nonnegative(),
-      promptName: z5.string().min(1).max(512),
+      position: z6.number().int().nonnegative(),
+      promptName: z6.string().min(1).max(512),
       configuration: CommerceConfigurationSchema,
-      toolDescriptors: z5.array(ToolDescriptorSchema).max(32)
+      toolDescriptors: z6.array(ToolDescriptorSchema).max(32)
     })
   ).min(1).max(32),
-  selectedCapabilityKeys: z5.array(IdSchema).min(1).max(32).refine(distinct),
+  selectedCapabilityKeys: z6.array(IdSchema).min(1).max(32).refine(distinct),
   grantedTools: GrantedToolsSchema,
   responseContract: CommerceResponseContractSchema,
   responseContractHash: HashSchema
@@ -660,32 +776,32 @@ var CommerceManifestSchema = z5.strictObject({
       message: "Grant must equal selected binding union"
     });
 });
-var CommerceReleaseIdentitySchema = z5.strictObject({
+var CommerceReleaseIdentitySchema = z6.strictObject({
   contractVersion: ContractVersionSchema,
   releaseId: IdSchema,
-  runnerCompatibility: z5.string().min(1).max(128).refine((v) => !!validRange(v))
+  runnerCompatibility: z6.string().min(1).max(128).refine((v) => !!validRange(v))
 });
 var CommerceResolveAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z5.literal("resolve") }
+  { purpose: z6.literal("resolve") }
 );
 var CommerceExecuteAssertionSchema = CommerceTurnIdentitySchema.extend(
-  { purpose: z5.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
+  { purpose: z6.literal("execute"), grantId: IdSchema, releaseId: IdSchema }
 );
-var CommerceAssertionSchema = z5.discriminatedUnion("purpose", [
+var CommerceAssertionSchema = z6.discriminatedUnion("purpose", [
   CommerceResolveAssertionSchema,
   CommerceExecuteAssertionSchema
 ]);
-var qty = z5.number().int().min(1).max(999);
-var CommerceProposalSchema = z5.strictObject({
-  operations: z5.array(
-    z5.discriminatedUnion("kind", [
-      z5.strictObject({
-        kind: z5.literal("ADD"),
+var qty = z6.number().int().min(1).max(999);
+var CommerceProposalSchema = z6.strictObject({
+  operations: z6.array(
+    z6.discriminatedUnion("kind", [
+      z6.strictObject({
+        kind: z6.literal("ADD"),
         variantId: IdSchema,
         quantity: qty
       }),
-      z5.strictObject({
-        kind: z5.literal("REPLACE"),
+      z6.strictObject({
+        kind: z6.literal("REPLACE"),
         lineId: IdSchema,
         variantId: IdSchema,
         quantity: qty
@@ -697,13 +813,13 @@ var CommerceProposalSchema = z5.strictObject({
     v.operations.flatMap((o) => o.kind === "REPLACE" ? [o.lineId] : [])
   )
 );
-var CommerceBasketSchema = z5.strictObject({
+var CommerceBasketSchema = z6.strictObject({
   basketId: IdSchema,
-  source: z5.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
+  source: z6.enum(["RECOVERY_SNAPSHOT", "PROPOSED"]),
   observedAt: DateSchema,
   currency: CurrencySchema.nullable(),
-  lines: z5.array(
-    z5.strictObject({
+  lines: z6.array(
+    z6.strictObject({
       lineId: IdSchema,
       productId: IdSchema.nullable(),
       variantId: IdSchema.nullable(),
@@ -712,40 +828,40 @@ var CommerceBasketSchema = z5.strictObject({
     })
   ).max(100),
   fingerprint: HashSchema,
-  unknownFields: z5.array(z5.string().min(1).max(256)).max(128)
+  unknownFields: z6.array(z6.string().min(1).max(256)).max(128)
 }).refine((v) => distinct(v.lines.map((line) => line.lineId)));
-var CommerceProductSchema = z5.strictObject({
+var CommerceProductSchema = z6.strictObject({
   productId: IdSchema,
   variantId: IdSchema,
-  title: z5.string().min(1).max(512),
-  url: z5.url({ protocol: /^https$/ }).refine((v) => {
+  title: z6.string().min(1).max(512),
+  url: z6.url({ protocol: /^https$/ }).refine((v) => {
     const u = new URL(v);
     return !u.username && !u.password && !u.port;
   }).nullable(),
-  available: z5.boolean().nullable(),
+  available: z6.boolean().nullable(),
   unitPrice: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
-  productType: z5.string().max(512).nullable(),
-  vendor: z5.string().max(512).nullable(),
+  productType: z6.string().max(512).nullable(),
+  vendor: z6.string().max(512).nullable(),
   observedAt: DateSchema
 });
-var CommerceOfferSchema = z5.strictObject({
+var CommerceOfferSchema = z6.strictObject({
   offerId: IdSchema,
-  title: z5.string().min(1).max(512),
-  method: z5.enum(["AUTOMATIC", "CODE"]),
-  code: z5.string().min(1).max(128).nullable(),
+  title: z6.string().min(1).max(512),
+  method: z6.enum(["AUTOMATIC", "CODE"]),
+  code: z6.string().min(1).max(128).nullable(),
   startsAt: DateSchema.nullable(),
   endsAt: DateSchema.nullable(),
-  support: z5.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
-  reasonCodes: z5.array(z5.string().min(1).max(64)).max(16)
+  support: z6.enum(["SUPPORTED", "UNSUPPORTED", "UNKNOWN"]),
+  reasonCodes: z6.array(z6.string().min(1).max(64)).max(16)
 }).refine(
   (v) => (v.startsAt === null || v.endsAt === null || Date.parse(v.startsAt) < Date.parse(v.endsAt)) && (v.method !== "AUTOMATIC" || v.code === null)
 );
-var condition = z5.strictObject({
-  code: z5.string().min(1).max(64),
-  description: z5.string().max(256)
+var condition = z6.strictObject({
+  code: z6.string().min(1).max(64),
+  description: z6.string().max(256)
 });
-var CommerceEvidenceSchema = z5.strictObject({
+var CommerceEvidenceSchema = z6.strictObject({
   evidenceId: HashSchema,
   turn: CommerceTurnIdentitySchema,
   grantId: IdSchema,
@@ -756,7 +872,7 @@ var CommerceEvidenceSchema = z5.strictObject({
   ruleFingerprint: HashSchema,
   evaluatedAt: DateSchema,
   expiresAt: DateSchema,
-  outcome: z5.enum([
+  outcome: z6.enum([
     "QUALIFIES_FOR_KNOWN_RULES",
     "DOES_NOT_QUALIFY",
     "UNKNOWN",
@@ -765,8 +881,8 @@ var CommerceEvidenceSchema = z5.strictObject({
   currency: CurrencySchema.nullable(),
   savings: MoneySchema.nullable(),
   resultingTotal: MoneySchema.nullable(),
-  evaluatedConditions: z5.array(condition).max(32),
-  unresolvedConditions: z5.array(condition).max(32)
+  evaluatedConditions: z6.array(condition).max(32),
+  unresolvedConditions: z6.array(condition).max(32)
 }).superRefine((v, c) => {
   if (Date.parse(v.expiresAt) - Date.parse(v.evaluatedAt) > 6e4)
     c.addIssue({
@@ -776,16 +892,16 @@ var CommerceEvidenceSchema = z5.strictObject({
   if (v.outcome === "QUALIFIES_FOR_KNOWN_RULES" && (v.unresolvedConditions.length || Date.parse(v.expiresAt) <= Date.parse(v.evaluatedAt) || v.currency === null || v.savings === null || v.resultingTotal === null))
     c.addIssue({ code: "custom", message: "Unsupported qualifying claim" });
 });
-var CommerceAlternativeSchema = z5.strictObject({
+var CommerceAlternativeSchema = z6.strictObject({
   product: CommerceProductSchema,
   proposal: CommerceProposalSchema,
   extraSpend: MoneySchema.nullable(),
   resultingTotal: MoneySchema.nullable(),
   currency: CurrencySchema.nullable(),
   evidence: CommerceEvidenceSchema.nullable(),
-  similarityReasons: z5.array(z5.string().max(256)).max(3)
+  similarityReasons: z6.array(z6.string().max(256)).max(3)
 }).refine((v) => v.product.available === true);
-var CommerceErrorCodeSchema = z5.enum([
+var CommerceErrorCodeSchema = z6.enum([
   "INVALID_INPUT",
   "DENIED",
   "STALE_TURN",
@@ -796,66 +912,66 @@ var CommerceErrorCodeSchema = z5.enum([
   "INCOMPATIBLE_VERSION"
 ]);
 function commerceToolResultSchema(data) {
-  return z5.union([
-    z5.strictObject({
+  return z6.union([
+    z6.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z5.literal("OK"),
+      status: z6.literal("OK"),
       data,
-      renderedText: z5.string().max(4096)
+      renderedText: z6.string().max(4096)
     }),
-    z5.strictObject({
+    z6.strictObject({
       contractVersion: ContractVersionSchema,
-      status: z5.literal("ERROR"),
+      status: z6.literal("ERROR"),
       code: CommerceErrorCodeSchema,
-      retryable: z5.boolean(),
-      renderedText: z5.string().max(4096).optional()
+      retryable: z6.boolean(),
+      renderedText: z6.string().max(4096).optional()
     })
   ]);
 }
 var CommerceToolResultSchema = commerceToolResultSchema(
   boundedJson(262144)
 );
-var limit = z5.number().int().min(1).max(3).default(3);
+var limit = z6.number().int().min(1).max(3).default(3);
 var CommerceToolInputs = {
-  commerce_get_basket: z5.strictObject({}),
-  commerce_search_products: z5.strictObject({
-    query: z5.string().min(1).max(200),
+  commerce_get_basket: z6.strictObject({}),
+  commerce_search_products: z6.strictObject({
+    query: z6.string().min(1).max(200),
     maximumPrice: MoneySchema.optional(),
-    availableOnly: z5.boolean().default(true),
-    limit: z5.number().int().min(1).max(20).default(10),
-    cursor: z5.string().max(2048).nullable().default(null)
+    availableOnly: z6.boolean().default(true),
+    limit: z6.number().int().min(1).max(20).default(10),
+    cursor: z6.string().max(2048).nullable().default(null)
   }),
-  commerce_get_discount_options: z5.strictObject({}),
-  commerce_evaluate_discount: z5.strictObject({
+  commerce_get_discount_options: z6.strictObject({}),
+  commerce_evaluate_discount: z6.strictObject({
     offerId: IdSchema,
     proposal: CommerceProposalSchema.nullable()
   }),
-  commerce_find_qualifying_products: z5.strictObject({
+  commerce_find_qualifying_products: z6.strictObject({
     offerId: IdSchema,
-    query: z5.string().min(1).max(200).nullable(),
+    query: z6.string().min(1).max(200).nullable(),
     limit
   }),
-  commerce_find_similar_products: z5.strictObject({
+  commerce_find_similar_products: z6.strictObject({
     variantId: IdSchema,
     offerId: IdSchema.nullable(),
     limit
   })
 };
-var alternatives = z5.strictObject({
-  alternatives: z5.array(CommerceAlternativeSchema).max(3),
-  truncated: z5.boolean()
+var alternatives = z6.strictObject({
+  alternatives: z6.array(CommerceAlternativeSchema).max(3),
+  truncated: z6.boolean()
 });
 var CommerceToolOutputs = {
   commerce_get_basket: CommerceBasketSchema,
-  commerce_search_products: z5.strictObject({
-    products: z5.array(CommerceProductSchema).max(20),
-    cursor: z5.string().max(2048).nullable(),
-    truncated: z5.boolean()
+  commerce_search_products: z6.strictObject({
+    products: z6.array(CommerceProductSchema).max(20),
+    cursor: z6.string().max(2048).nullable(),
+    truncated: z6.boolean()
   }),
-  commerce_get_discount_options: z5.strictObject({
-    mode: z5.enum(["NONE", "FIXED", "AI_BEST_APPLICABLE"]),
-    offers: z5.array(CommerceOfferSchema).max(50),
-    truncated: z5.boolean()
+  commerce_get_discount_options: z6.strictObject({
+    mode: z6.enum(["NONE", "FIXED", "AI_BEST_APPLICABLE"]),
+    offers: z6.array(CommerceOfferSchema).max(50),
+    truncated: z6.boolean()
   }),
   commerce_evaluate_discount: CommerceEvidenceSchema,
   commerce_find_qualifying_products: alternatives,
@@ -870,20 +986,20 @@ function productBelongsToDomain(product, verifiedDomain) {
 }
 
 // src/commerce/selection.ts
-import { z as z6 } from "zod";
-var CommerceCapabilityBindingSchema = z6.discriminatedUnion("kind", [
-  z6.strictObject({
-    kind: z6.literal("BASE"),
-    key: z6.literal("conversation_core")
+import { z as z7 } from "zod";
+var CommerceCapabilityBindingSchema = z7.discriminatedUnion("kind", [
+  z7.strictObject({
+    kind: z7.literal("BASE"),
+    key: z7.literal("conversation_core")
   }),
-  z6.strictObject({
-    kind: z6.literal("FEATURE"),
+  z7.strictObject({
+    kind: z7.literal("FEATURE"),
     key: IdSchema,
     featureId: IdSchema
   }),
-  z6.strictObject({
-    kind: z6.literal("RECOVERY_POLICY"),
-    key: z6.literal("discount_assistance")
+  z7.strictObject({
+    kind: z7.literal("RECOVERY_POLICY"),
+    key: z7.literal("discount_assistance")
   })
 ]);
 function selectCapabilities(candidates, facts) {
@@ -970,6 +1086,23 @@ export {
   LanguageSchema,
   distinct,
   boundedJson,
+  ExternalQueryMappingSchema,
+  ExternalQueryMappingsSchema,
+  ExternalPathSchema,
+  ExternalResponseFormatSchema,
+  FieldProjectionSchema,
+  ResponseFilterSchema,
+  VisualResponseProcessingSchema,
+  ResponseProcessingSchema,
+  TransformResponseSchema,
+  TransformSampleSchema,
+  ConnectionRevisionViewSchema,
+  ConnectionViewSchema,
+  CredentialStatusSchema,
+  ConnectionCommandSchema,
+  RevisionInputSchema,
+  ConnectionIssueSchema,
+  ConnectionResultSchema,
   ToolNameSchema,
   ToolBindingSchema,
   ToolBindingsSchema,
@@ -977,6 +1110,7 @@ export {
   GrantedToolsSchema,
   ToolDescriptorSchema,
   POLICY_OPERATIONS,
+  ExternalHttpExecutionSchema,
   CommerceExecutionSchema,
   ResponseTemplateSchema,
   CommerceToolDefinitionSchema,
@@ -1024,4 +1158,4 @@ export {
   parseCommerceManifest,
   currentlyGrantedTools
 };
-//# sourceMappingURL=chunk-QNANS4R4.js.map
+//# sourceMappingURL=chunk-GLNBHQKH.js.map