@modainteract/moda-interact-shared 0.13.1 → 0.14.1

package/dist/{chunk-OIRLIV5F.js → chunk-WVQWQFVR.js}

@@ -218,8 +218,65 @@ 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 ExternalQueryValueSchema = scalar;
+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("}") && value.split("/").every((segment) => segment !== "." && segment !== "..")
+);
+var mediaType = z3.string().min(1).max(128).refine((value) => value === value.toLowerCase() && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(value));
+var jsonMime = (value) => value === "application/json" || /^application\/[a-z0-9!#$&^_.+-]+\+json$/.test(value);
+var textMime = (value) => /^text\/[a-z0-9!#$&^_.+-]+$/.test(value) || value === "application/xml" || /^application\/[a-z0-9!#$&^_.+-]+\+xml$/.test(value) || jsonMime(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) }).refine((value) => value.mediaTypes.every(value.mode === "JSON" ? jsonMime : textMime));
+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 boundedValues = z3.custom((value) => {
+  const visit = (node, depth) => depth <= 20 && (node === null || typeof node === "string" || typeof node === "boolean" || typeof node === "number" && Number.isFinite(node) || Array.isArray(node) && node.every((child) => visit(child, depth + 1)) || !!node && typeof node === "object" && !Array.isArray(node) && Object.getPrototypeOf(node) === Object.prototype && Object.entries(node).every(([key, child]) => !["__proto__", "prototype", "constructor"].includes(key) && visit(child, depth + 1)));
+  try {
+    return !!value && typeof value === "object" && !Array.isArray(value) && visit(value, 1) && jsonBytes(value) <= 49152;
+  } catch {
+    return false;
+  }
+});
+var ExternalHttpResultDataSchema = z3.strictObject({ source: z3.literal("EXTERNAL_HTTP"), connectionRevisionId: IdSchema, observedAt: DateSchema, values: boundedValues });
+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";
 
 // src/commerce/definition-size.ts
@@ -260,38 +317,38 @@ var definitionFitsStorage = (value) => {
 var DEFINITION_SIZE_MESSAGE = "Definition exceeds the 65536-byte jsonb text limit";
 
 // src/commerce/definitions.ts
-var ToolNameSchema = z3.string().regex(/^[a-z][a-z0-9_]{0,127}$/).refine((n) => n !== "finalResponse");
-var ToolBindingSchema = z3.strictObject({
+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",
@@ -300,23 +357,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;
@@ -326,17 +401,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
   })
@@ -344,10 +419,11 @@ 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 forbiddenExternalInput = /^(authorization|cookie|set-cookie|host|x-api-key|api_key|apikey|access_token|token|secret|password)$/i;
+var CommerceToolDefinitionSchema = z4.strictObject({
   ...identity,
   inputSchema: InputSchemaSchema,
   execution: CommerceExecutionSchema,
@@ -362,7 +438,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({
@@ -370,16 +446,49 @@ 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 (forbiddenExternalInput.test(mapping2.input) || !["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(definitionFitsStorage, { message: DEFINITION_SIZE_MESSAGE });
+function externalOutputSchema(execution) {
+  return {
+    type: "object",
+    properties: { values: execution.resultSchema },
+    required: ["values"],
+    additionalProperties: false
+  };
+}
+function scalarSchema(schema) {
+  const type = schema && (Array.isArray(schema.type) ? schema.type[0] : schema.type);
+  return !!schema && ["string", "integer", "number", "boolean"].includes(type ?? "");
+}
+function visualPublicationCompatible(execution) {
+  if (execution.responseProcessing.kind === "JAVASCRIPT") return true;
+  const processing = execution.responseProcessing;
+  const schema = execution.resultSchema;
+  if (processing.kind === "LIST" && (!schema.properties?.items || schema.properties.items.type !== "array" || !(schema.required ?? []).includes("items"))) return false;
+  const output = processing.kind === "OBJECT" ? schema : schema.properties?.items?.items;
+  if (!output || output.type !== "object" || !output.properties || output.additionalProperties !== false) return false;
+  const fields = processing.fields;
+  if (Object.keys(output.properties).some((name) => !Object.hasOwn(fields, name) || !scalarSchema(output.properties[name]))) return false;
+  if (Object.keys(fields).some((name) => !Object.hasOwn(output.properties, name))) return false;
+  return (output.required ?? []).every((name) => !fields[name]?.omitIfMissing);
+}
 function at(schema, path) {
   let current = schema;
   for (const part of path.split(".")) current = current?.properties?.[part];
@@ -387,10 +496,9 @@ function at(schema, path) {
 }
 function validateDefinitionForPublication(raw, compiler) {
   const definition = CommerceToolDefinitionSchema.parse(raw);
-  const compiled = compiler.compile(
-    definition.execution,
-    definition.inputSchema
-  );
+  if (definition.execution.kind === "EXTERNAL_HTTP" && !visualPublicationCompatible(definition.execution))
+    throw new TypeError("External visual projection is incompatible with resultSchema");
+  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;
@@ -415,12 +523,16 @@ 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;
-    else if (Object.hasOwn(input, m.input)) result[key] = input[m.input];
-    else if (!m.omitIfMissing) throw new TypeError("Missing mapped input");
+    else if (Object.hasOwn(input, m.input)) {
+      const value = input[m.input];
+      if (definition.execution.kind === "EXTERNAL_HTTP" && !ExternalQueryValueSchema.safeParse(value).success)
+        throw new TypeError("Invalid external mapped scalar");
+      result[key] = value;
+    } else if (!m.omitIfMissing) throw new TypeError("Missing mapped input");
   }
   return result;
 }
@@ -446,12 +558,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,
@@ -462,10 +574,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 = {
@@ -478,20 +590,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 {
@@ -602,22 +714,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,
@@ -630,25 +742,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
@@ -699,32 +811,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
@@ -736,13 +848,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(),
@@ -751,40 +863,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,
@@ -795,7 +907,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",
@@ -804,8 +916,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({
@@ -815,16 +927,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",
@@ -835,66 +947,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,
@@ -909,20 +1021,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) {
@@ -1009,6 +1121,25 @@ export {
   LanguageSchema,
   distinct,
   boundedJson,
+  ExternalQueryValueSchema,
+  ExternalQueryMappingSchema,
+  ExternalQueryMappingsSchema,
+  ExternalPathSchema,
+  ExternalResponseFormatSchema,
+  FieldProjectionSchema,
+  ResponseFilterSchema,
+  VisualResponseProcessingSchema,
+  ResponseProcessingSchema,
+  TransformResponseSchema,
+  TransformSampleSchema,
+  ExternalHttpResultDataSchema,
+  ConnectionRevisionViewSchema,
+  ConnectionViewSchema,
+  CredentialStatusSchema,
+  ConnectionCommandSchema,
+  RevisionInputSchema,
+  ConnectionIssueSchema,
+  ConnectionResultSchema,
   ToolNameSchema,
   ToolBindingSchema,
   ToolBindingsSchema,
@@ -1016,6 +1147,7 @@ export {
   GrantedToolsSchema,
   ToolDescriptorSchema,
   POLICY_OPERATIONS,
+  ExternalHttpExecutionSchema,
   CommerceExecutionSchema,
   ResponseTemplateSchema,
   CommerceToolDefinitionSchema,
@@ -1063,4 +1195,4 @@ export {
   parseCommerceManifest,
   currentlyGrantedTools
 };
-//# sourceMappingURL=chunk-OIRLIV5F.js.map
+//# sourceMappingURL=chunk-WVQWQFVR.js.map