@executor-js/plugin-openapi 1.5.17 → 1.5.18

package/dist/{chunk-UEKOP6NZ.js → chunk-ELCKZJE4.js}

@@ -1,7 +1,7 @@
 import {
   deriveAuthenticationTemplateFromPreview,
   firstBaseUrlForPreview
-} from "./chunk-CKBX4SXK.js";
+} from "./chunk-5IDND4UF.js";
 import {
   openApiPresets
 } from "./chunk-QQFCICLX.js";
@@ -11,13 +11,19 @@ import {
   OpenApiInvocationError,
   OpenApiParseError,
   OperationBinding,
+  buildInputSchema,
+  compileToolDefinitions,
   extract,
   normalizeOpenApiAuthInputs,
   parse,
+  parseEntry,
   previewSpecText,
   resolveServerUrl,
-  resolveSpecText
-} from "./chunk-KVPUDOJZ.js";
+  resolveSpecText,
+  streamOperationBindings,
+  streamOperationBindingsFromStructure,
+  structuralSplit
+} from "./chunk-R3X27XS6.js";
 
 // src/sdk/config.ts
 import { Option, Schema } from "effect";
@@ -78,7 +84,12 @@ var toJsonRecord = (value) => value;
 var OperationStorage = Schema2.Struct({
   integration: Schema2.String,
   toolName: Schema2.String,
-  binding: Schema2.Unknown
+  binding: Schema2.Unknown,
+  // Resolved tool description (operation description / summary / method+path
+  // fallback), persisted so the serve path can rebuild the tool def without
+  // re-parsing the spec. Optional: legacy rows predate it and resolve via the
+  // parse fallback.
+  description: Schema2.optional(Schema2.String)
 });
 var decodeOperationStorage = Schema2.decodeUnknownOption(OperationStorage);
 var rowToOperation = (row) => {
@@ -90,7 +101,8 @@ var rowToOperation = (row) => {
     toolName: operation.toolName,
     binding: decodeBinding(
       typeof operation.binding === "string" ? decodeBindingJson(operation.binding) : operation.binding
-    )
+    ),
+    ...operation.description !== void 0 ? { description: operation.description } : {}
   };
 };
 var stableKeyHash = (value) => {
@@ -106,11 +118,13 @@ var stableKeyHash = (value) => {
 var operationKey = (integration, toolName) => `${OPERATION_KEY_VERSION}.${stableKeyHash(integration)}.${stableKeyHash(toolName)}`;
 var legacyOperationKey = (integration, toolName) => `${integration}.${toolName}`;
 var specBlobKey = (specHash) => `spec/${specHash}`;
+var defsBlobKey = (specHash) => `defs/${specHash}`;
 var makeDefaultOpenapiStore = ({ pluginStorage, blobs }) => {
   const operationData = (operation) => ({
     integration: operation.integration,
     toolName: operation.toolName,
-    binding: toJsonRecord(encodeBinding(operation.binding))
+    binding: toJsonRecord(encodeBinding(operation.binding)),
+    ...operation.description !== void 0 ? { description: operation.description } : {}
   });
   const listRows = (integration) => pluginStorage.list({ collection: OPERATION_COLLECTION }).pipe(
     Effect.map(
@@ -124,18 +138,20 @@ var makeDefaultOpenapiStore = ({ pluginStorage, blobs }) => {
       entries: rows.map((row) => ({ collection: OPERATION_COLLECTION, key: row.key }))
     });
   });
+  const appendOperations = (integration, operations) => pluginStorage.putMany({
+    owner: STORE_OWNER,
+    entries: operations.map((operation) => ({
+      collection: OPERATION_COLLECTION,
+      key: operationKey(integration, operation.toolName),
+      data: operationData(operation)
+    }))
+  });
   return {
     putOperations: (integration, operations) => Effect.gen(function* () {
       yield* removeOperations(integration);
-      yield* pluginStorage.putMany({
-        owner: STORE_OWNER,
-        entries: operations.map((operation) => ({
-          collection: OPERATION_COLLECTION,
-          key: operationKey(integration, operation.toolName),
-          data: operationData(operation)
-        }))
-      });
+      yield* appendOperations(integration, operations);
     }),
+    appendOperations,
     getOperation: (integration, toolName) => Effect.gen(function* () {
       const row = yield* pluginStorage.get({
         collection: OPERATION_COLLECTION,
@@ -155,7 +171,9 @@ var makeDefaultOpenapiStore = ({ pluginStorage, blobs }) => {
     ),
     removeOperations,
     putSpec: (specHash, specText) => blobs.put(specBlobKey(specHash), specText, { owner: STORE_OWNER }),
-    getSpec: (specHash) => blobs.get(specBlobKey(specHash))
+    getSpec: (specHash) => blobs.get(specBlobKey(specHash)),
+    putDefs: (specHash, defsJson) => blobs.put(defsBlobKey(specHash), defsJson, { owner: STORE_OWNER }),
+    getDefs: (specHash) => blobs.get(defsBlobKey(specHash))
   };
 };
 
@@ -656,160 +674,13 @@ var annotationsForOperation = (method, pathTemplate) => {
 };
 
 // src/sdk/backing.ts
-import { Effect as Effect3, Option as Option5, Schema as Schema3 } from "effect";
+import { Effect as Effect3, Option as Option4, Schema as Schema3 } from "effect";
 import {
   ToolFileJsonSchema,
   ToolName,
   ToolResult,
   authToolFailure
 } from "@executor-js/sdk/core";
-
-// src/sdk/definitions.ts
-import { Option as Option4 } from "effect";
-var splitWords = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z0-9]+)/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").trim().split(/\s+/).filter((part) => part.length > 0);
-var normalizeWord = (value) => value.toLowerCase();
-var toCamelCase = (value) => {
-  const words = splitWords(value).map(normalizeWord);
-  if (words.length === 0) return "tool";
-  const [first, ...rest] = words;
-  return `${first}${rest.map((p) => `${p[0]?.toUpperCase() ?? ""}${p.slice(1)}`).join("")}`;
-};
-var toPascalCase = (value) => {
-  const camel = toCamelCase(value);
-  return `${camel[0]?.toUpperCase() ?? ""}${camel.slice(1)}`;
-};
-var VERSION_SEGMENT_REGEX = /^v\d+(?:[._-]\d+)?$/i;
-var IGNORED_PATH_SEGMENTS = /* @__PURE__ */ new Set(["api"]);
-var pathSegmentsFromTemplate = (pathTemplate) => pathTemplate.split("/").map((s) => s.trim()).filter((s) => s.length > 0);
-var isPathParameterSegment = (segment) => segment.startsWith("{") && segment.endsWith("}");
-var normalizeGroupSegment = (value) => {
-  const candidate = value?.trim();
-  if (!candidate) return null;
-  return toCamelCase(candidate);
-};
-var deriveVersionSegment = (pathTemplate) => pathSegmentsFromTemplate(pathTemplate).map((s) => s.toLowerCase()).find((s) => VERSION_SEGMENT_REGEX.test(s));
-var derivePathGroup = (pathTemplate) => {
-  for (const segment of pathSegmentsFromTemplate(pathTemplate)) {
-    const lower = segment.toLowerCase();
-    if (VERSION_SEGMENT_REGEX.test(lower)) continue;
-    if (IGNORED_PATH_SEGMENTS.has(lower)) continue;
-    if (isPathParameterSegment(segment)) continue;
-    return normalizeGroupSegment(segment) ?? "root";
-  }
-  return "root";
-};
-var splitOperationIdSegments = (value) => value.split(/[/.]+/).map((s) => s.trim()).filter((s) => s.length > 0);
-var deriveLeafSeed = (operationId, group) => {
-  const segments = splitOperationIdSegments(operationId);
-  if (segments.length > 1) {
-    const [first, ...rest] = segments;
-    if ((normalizeGroupSegment(first) ?? first) === group && rest.length > 0) {
-      return rest.join(" ");
-    }
-  }
-  return operationId;
-};
-var fallbackLeafSeed = (method, pathTemplate, group) => {
-  const relevantSegments = pathSegmentsFromTemplate(pathTemplate).filter((s) => !VERSION_SEGMENT_REGEX.test(s.toLowerCase())).filter((s) => !IGNORED_PATH_SEGMENTS.has(s.toLowerCase())).filter((s) => !isPathParameterSegment(s)).map((s) => normalizeGroupSegment(s) ?? s).filter((s) => s !== group);
-  const segmentSuffix = relevantSegments.map((s) => toPascalCase(s)).join("");
-  return `${method}${segmentSuffix || "Operation"}`;
-};
-var deriveLeaf = (operationId, method, pathTemplate, group) => {
-  const preferred = toCamelCase(deriveLeafSeed(operationId, group));
-  if (preferred.length > 0 && preferred !== group) return preferred;
-  return toCamelCase(fallbackLeafSeed(method, pathTemplate, group));
-};
-var resolveCollisions = (definitions) => {
-  const staged = definitions.map((d) => ({ ...d }));
-  const applyFactory = (items, factory) => {
-    const byPath = /* @__PURE__ */ new Map();
-    for (const item of items) {
-      const bucket = byPath.get(item.toolPath) ?? [];
-      bucket.push(item);
-      byPath.set(item.toolPath, bucket);
-    }
-    for (const bucket of byPath.values()) {
-      if (bucket.length < 2) continue;
-      for (const d of bucket) {
-        d.toolPath = factory(d);
-      }
-    }
-  };
-  applyFactory(
-    staged,
-    (d) => d.versionSegment ? `${d.group}.${d.versionSegment}.${d.leaf}` : d.toolPath
-  );
-  applyFactory(staged, (d) => {
-    const prefix = d.versionSegment ? `${d.group}.${d.versionSegment}` : d.group;
-    return `${prefix}.${d.leaf}${toPascalCase(d.method)}`;
-  });
-  applyFactory(staged, (d) => {
-    const prefix = d.versionSegment ? `${d.group}.${d.versionSegment}` : d.group;
-    return `${prefix}.${d.leaf}${toPascalCase(d.method)}${d.operationHash.slice(0, 8)}`;
-  });
-  return staged.map((d) => ({
-    toolPath: d.toolPath,
-    group: d.group,
-    leaf: d.leaf,
-    operationIndex: d.operationIndex,
-    operation: d.operation
-  }));
-};
-var stableHash = (value) => {
-  const str = JSON.stringify(value, Object.keys(value).sort());
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
-  }
-  return Math.abs(hash).toString(36).padStart(8, "0");
-};
-var compileToolDefinitions = (operations) => {
-  const raw = operations.map((op, index) => {
-    const operationId = op.operationId;
-    const explicitToolPath = Option4.getOrUndefined(op.toolPath);
-    if (explicitToolPath) {
-      const [group2 = "root", ...leafParts] = explicitToolPath.split(".").filter(Boolean);
-      const leaf2 = leafParts.join(".") || group2;
-      const versionSegment2 = deriveVersionSegment(op.pathTemplate);
-      const operationHash2 = stableHash({
-        method: op.method,
-        path: op.pathTemplate,
-        operationId
-      });
-      return {
-        toolPath: explicitToolPath,
-        group: group2,
-        leaf: leaf2,
-        versionSegment: versionSegment2,
-        method: op.method,
-        operationHash: operationHash2,
-        operationIndex: index,
-        operation: op
-      };
-    }
-    const group = normalizeGroupSegment(op.tags[0]) ?? derivePathGroup(op.pathTemplate);
-    const leaf = deriveLeaf(operationId, op.method, op.pathTemplate, group);
-    const versionSegment = deriveVersionSegment(op.pathTemplate);
-    const operationHash = stableHash({
-      method: op.method,
-      path: op.pathTemplate,
-      operationId
-    });
-    return {
-      toolPath: `${group}.${leaf}`,
-      group,
-      leaf,
-      versionSegment,
-      method: op.method,
-      operationHash,
-      operationIndex: index,
-      operation: op
-    };
-  });
-  return resolveCollisions(raw).sort((a, b) => a.toolPath.localeCompare(b.toolPath));
-};
-
-// src/sdk/backing.ts
 var STRINGIFIED_BODY_CAP = 1024;
 var UpstreamMessageBody = Schema3.Struct({ message: Schema3.String });
 var UpstreamErrorMessageBody = Schema3.Struct({ errorMessage: Schema3.String });
@@ -847,11 +718,11 @@ var extractOpenApiUpstreamMessage = (body, status) => {
   if (typeof body === "string") {
     return body.length > 0 ? body : `Upstream returned HTTP ${status}`;
   }
-  const nested = Option5.getOrUndefined(decodeUpstreamNestedErrorBody(body));
-  const messageBody = Option5.getOrUndefined(decodeUpstreamMessageBody(body));
-  const errorMessageBody = Option5.getOrUndefined(decodeUpstreamErrorMessageBody(body));
-  const errorsBody = Option5.getOrUndefined(decodeUpstreamErrorsArrayBody(body));
-  const descriptionBody = Option5.getOrUndefined(decodeUpstreamDescriptionBody(body));
+  const nested = Option4.getOrUndefined(decodeUpstreamNestedErrorBody(body));
+  const messageBody = Option4.getOrUndefined(decodeUpstreamMessageBody(body));
+  const errorMessageBody = Option4.getOrUndefined(decodeUpstreamErrorMessageBody(body));
+  const errorsBody = Option4.getOrUndefined(decodeUpstreamErrorsArrayBody(body));
+  const descriptionBody = Option4.getOrUndefined(decodeUpstreamDescriptionBody(body));
   const arrayMessage = errorsBody?.errors.map(
     ({
       detail,
@@ -926,11 +797,15 @@ var toBinding = (def) => OperationBinding.make({
 });
 var descriptionFor = (def) => {
   const op = def.operation;
-  return Option5.getOrElse(
+  return Option4.getOrElse(
     op.description,
-    () => Option5.getOrElse(op.summary, () => `${op.method.toUpperCase()} ${op.pathTemplate}`)
+    () => Option4.getOrElse(op.summary, () => `${op.method.toUpperCase()} ${op.pathTemplate}`)
   );
 };
+var FILE_OUTPUT_HINT = `Returns a ToolFile: the file bytes already decoded into { _tag: "ToolFile", mimeType, encoding, data, byteLength }. To display or forward it, pass the result's data straight to emit(result.data). Do not rebuild the envelope or read upstream fields like size.`;
+var withFileEmitHint = (description, returnsFile) => returnsFile ? `${description}
+
+${FILE_OUTPUT_HINT}` : description;
 var compileOpenApiDocument = (doc) => Effect3.gen(function* () {
   const result = yield* extract(doc);
   const hoistedDefs = {};
@@ -942,38 +817,181 @@ var compileOpenApiDocument = (doc) => Effect3.gen(function* () {
   return {
     definitions: compileToolDefinitions(result.operations),
     hoistedDefs,
-    title: Option5.getOrUndefined(result.title),
-    description: Option5.getOrUndefined(result.description)
+    title: Option4.getOrUndefined(result.title),
+    description: Option4.getOrUndefined(result.description)
   };
 });
 var compileOpenApiSpec = (specText) => Effect3.gen(function* () {
   const doc = yield* parse(specText);
   return yield* compileOpenApiDocument(doc);
 });
-var openApiToolDefsFromCompiled = (compiled) => compiled.definitions.map(
-  (def) => ({
+var openApiToolDefsFromCompiled = (compiled) => compiled.definitions.map((def) => {
+  const returnsFile = Option4.match(def.operation.responseBody, {
+    onNone: () => false,
+    onSome: (responseBody) => Option4.isSome(responseBody.fileHint)
+  });
+  return {
     name: ToolName.make(def.toolPath),
-    description: descriptionFor(def),
-    inputSchema: normalizeOpenApiRefs(Option5.getOrUndefined(def.operation.inputSchema)),
-    outputSchema: Option5.match(def.operation.responseBody, {
-      onNone: () => normalizeOpenApiRefs(Option5.getOrUndefined(def.operation.outputSchema)),
-      onSome: (responseBody) => Option5.isSome(responseBody.fileHint) ? ToolFileJsonSchema : normalizeOpenApiRefs(Option5.getOrUndefined(def.operation.outputSchema))
-    }),
+    description: withFileEmitHint(descriptionFor(def), returnsFile),
+    inputSchema: normalizeOpenApiRefs(Option4.getOrUndefined(def.operation.inputSchema)),
+    outputSchema: returnsFile ? ToolFileJsonSchema : normalizeOpenApiRefs(Option4.getOrUndefined(def.operation.outputSchema)),
     annotations: annotationsForOperation(def.operation.method, def.operation.pathTemplate)
-  })
-);
+  };
+});
 var openApiStoredOperationsFromCompiled = (integration, compiled) => compiled.definitions.map((def) => ({
   integration,
   toolName: def.toolPath,
-  binding: toBinding(def)
+  binding: toBinding(def),
+  description: descriptionFor(def)
 }));
+var buildDefsJson = (doc) => {
+  const schemas = doc.components?.schemas;
+  if (!schemas) return "{}";
+  let json = "{";
+  let first = true;
+  for (const [name, schema] of Object.entries(schemas)) {
+    const serialized = JSON.stringify(normalizeOpenApiRefs(schema));
+    if (serialized === void 0) continue;
+    json += `${first ? "" : ","}${JSON.stringify(name)}:${serialized}`;
+    first = false;
+  }
+  return `${json}}`;
+};
+var buildDefsJsonStreaming = (structure) => {
+  let json = "{";
+  let first = true;
+  for (const range of structure.schemas) {
+    const entry = parseEntry(structure.text, range, 4);
+    if (!entry) continue;
+    const [name, schema] = entry;
+    const serialized = JSON.stringify(normalizeOpenApiRefs(schema));
+    if (serialized === void 0) continue;
+    json += `${first ? "" : ","}${JSON.stringify(name)}:${serialized}`;
+    first = false;
+  }
+  return `${json}}`;
+};
+var DefsJson = Schema3.Record(Schema3.String, Schema3.Unknown);
+var decodeDefsJson = Schema3.decodeUnknownOption(Schema3.fromJsonString(DefsJson));
+var toolDefFromStoredOperation = (op) => {
+  const binding = op.binding;
+  const returnsFile = Option4.match(binding.responseBody, {
+    onNone: () => false,
+    onSome: (responseBody) => Option4.isSome(responseBody.fileHint)
+  });
+  return {
+    name: ToolName.make(op.toolName),
+    description: withFileEmitHint(
+      op.description ?? `${binding.method.toUpperCase()} ${binding.pathTemplate}`,
+      returnsFile
+    ),
+    inputSchema: normalizeOpenApiRefs(
+      buildInputSchema(
+        binding.parameters,
+        Option4.getOrUndefined(binding.requestBody),
+        binding.servers ?? []
+      )
+    ),
+    outputSchema: returnsFile ? ToolFileJsonSchema : Option4.match(binding.responseBody, {
+      onNone: () => void 0,
+      onSome: (responseBody) => normalizeOpenApiRefs(Option4.getOrUndefined(responseBody.schema))
+    }),
+    annotations: annotationsForOperation(binding.method, binding.pathTemplate)
+  };
+};
+var compileAndPersistOpenApiOperations = ({
+  doc,
+  integration,
+  storage,
+  specHash,
+  chunkSize
+}) => Effect3.gen(function* () {
+  yield* storage.removeOperations(integration);
+  const result = yield* streamOperationBindings(
+    doc,
+    chunkSize ?? 500,
+    (chunk) => storage.appendOperations(
+      integration,
+      chunk.map((item) => ({
+        integration,
+        toolName: item.toolName,
+        binding: item.binding,
+        description: item.description
+      }))
+    )
+  );
+  if (specHash != null) {
+    yield* storage.putDefs(specHash, buildDefsJson(doc));
+  }
+  return result;
+});
+var compileAndPersistOpenApiSpec = ({
+  specText,
+  integration,
+  storage,
+  specHash,
+  chunkSize
+}) => Effect3.gen(function* () {
+  const doc = yield* parse(specText);
+  return yield* compileAndPersistOpenApiOperations({
+    doc,
+    integration,
+    storage,
+    specHash,
+    chunkSize
+  });
+});
+var compileAndPersistOpenApiSpecStreaming = ({
+  specText,
+  integration,
+  storage,
+  specHash,
+  chunkSize,
+  keepPathItem
+}) => Effect3.gen(function* () {
+  const structure = structuralSplit(specText);
+  if (!structure) {
+    return yield* new OpenApiExtractionError({
+      message: "OpenAPI spec is not in the streamable block-YAML profile (no top-level `paths:` block); cannot stream-compile a spec this large in-band."
+    });
+  }
+  yield* storage.removeOperations(integration);
+  const result = yield* streamOperationBindingsFromStructure(
+    structure,
+    { chunkSize: chunkSize ?? 500, keepPathItem },
+    (chunk) => storage.appendOperations(
+      integration,
+      chunk.map((item) => ({
+        integration,
+        toolName: item.toolName,
+        binding: item.binding,
+        description: item.description
+      }))
+    )
+  );
+  if (specHash != null) {
+    yield* storage.putDefs(specHash, buildDefsJsonStreaming(structure));
+  }
+  return result;
+});
 var loadOpenApiSpecText = (storage, config) => config.specHash != null ? storage.getSpec(config.specHash) : Effect3.succeed(null);
 var resolveOpenApiBackedTools = ({
+  integration,
   config,
   storage
 }) => Effect3.gen(function* () {
   const openApiConfig = decodeOpenApiIntegrationConfig(config);
   if (!openApiConfig) return { tools: [], definitions: {} };
+  if (openApiConfig.specHash != null) {
+    const defsJson = yield* storage.getDefs(openApiConfig.specHash);
+    if (defsJson != null) {
+      const definitions = Option4.getOrNull(decodeDefsJson(defsJson));
+      if (definitions != null) {
+        const ops = yield* storage.listOperations(String(integration.slug));
+        return { tools: ops.map(toolDefFromStoredOperation), definitions };
+      }
+    }
+  }
   const specText = yield* loadOpenApiSpecText(storage, openApiConfig);
   if (specText == null) return { tools: [], definitions: {} };
   const compiled = yield* compileOpenApiSpec(specText).pipe(
@@ -989,7 +1007,7 @@ var invokeOpenApiBackedTool = (input) => Effect3.gen(function* () {
   const integration = input.toolRow.integration;
   const config = decodeOpenApiIntegrationConfig(input.credential.config);
   let binding = (yield* input.ctx.storage.getOperation(integration, input.toolRow.name))?.binding;
-  if ((!binding || Option5.isNone(binding.responseBody)) && config) {
+  if (!binding && config) {
     const specText = yield* loadOpenApiSpecText(input.ctx.storage, config).pipe(
       Effect3.catch(() => Effect3.succeed(null))
     );
@@ -1078,7 +1096,7 @@ var resolveOpenApiBackedAnnotations = (input) => Effect3.gen(function* () {
 });
 
 // src/sdk/plugin.ts
-import { Effect as Effect4, Option as Option6, Schema as Schema4 } from "effect";
+import { Effect as Effect4, Option as Option5, Schema as Schema4 } from "effect";
 import {
   IntegrationAlreadyExistsError,
   IntegrationDetectionResult,
@@ -1209,18 +1227,18 @@ var openApiToolFailure = (code, message, details) => ToolResult2.fail({
   ...details === void 0 ? {} : { details }
 });
 var staticPreviewOutput = (preview) => ({
-  title: Option6.getOrNull(preview.title),
-  version: Option6.getOrNull(preview.version),
+  title: Option5.getOrNull(preview.title),
+  version: Option5.getOrNull(preview.version),
   servers: preview.servers.map((server) => ({
     url: server.url,
-    description: Option6.getOrNull(server.description),
-    variables: Option6.getOrNull(server.variables) ? Object.fromEntries(
-      Object.entries(Option6.getOrNull(server.variables) ?? {}).map(([name, variable]) => [
+    description: Option5.getOrNull(server.description),
+    variables: Option5.getOrNull(server.variables) ? Object.fromEntries(
+      Object.entries(Option5.getOrNull(server.variables) ?? {}).map(([name, variable]) => [
         name,
         {
           default: variable.default,
-          enum: Option6.getOrNull(variable.enum),
-          description: Option6.getOrNull(variable.description)
+          enum: Option5.getOrNull(variable.enum),
+          description: Option5.getOrNull(variable.description)
         }
       ])
     ) : null
@@ -1230,25 +1248,25 @@ var staticPreviewOutput = (preview) => ({
   securitySchemes: preview.securitySchemes.map((scheme) => ({
     name: scheme.name,
     type: scheme.type,
-    scheme: Option6.getOrNull(scheme.scheme),
-    bearerFormat: Option6.getOrNull(scheme.bearerFormat),
-    in: Option6.getOrNull(scheme.in),
-    headerName: Option6.getOrNull(scheme.headerName),
-    description: Option6.getOrNull(scheme.description),
-    flows: Option6.isSome(scheme.flows) ? {
-      authorizationCode: Option6.isSome(scheme.flows.value.authorizationCode) ? {
+    scheme: Option5.getOrNull(scheme.scheme),
+    bearerFormat: Option5.getOrNull(scheme.bearerFormat),
+    in: Option5.getOrNull(scheme.in),
+    headerName: Option5.getOrNull(scheme.headerName),
+    description: Option5.getOrNull(scheme.description),
+    flows: Option5.isSome(scheme.flows) ? {
+      authorizationCode: Option5.isSome(scheme.flows.value.authorizationCode) ? {
         authorizationUrl: scheme.flows.value.authorizationCode.value.authorizationUrl,
         tokenUrl: scheme.flows.value.authorizationCode.value.tokenUrl,
-        refreshUrl: Option6.getOrNull(scheme.flows.value.authorizationCode.value.refreshUrl),
+        refreshUrl: Option5.getOrNull(scheme.flows.value.authorizationCode.value.refreshUrl),
         scopes: scheme.flows.value.authorizationCode.value.scopes
       } : null,
-      clientCredentials: Option6.isSome(scheme.flows.value.clientCredentials) ? {
+      clientCredentials: Option5.isSome(scheme.flows.value.clientCredentials) ? {
         tokenUrl: scheme.flows.value.clientCredentials.value.tokenUrl,
-        refreshUrl: Option6.getOrNull(scheme.flows.value.clientCredentials.value.refreshUrl),
+        refreshUrl: Option5.getOrNull(scheme.flows.value.clientCredentials.value.refreshUrl),
         scopes: scheme.flows.value.clientCredentials.value.scopes
       } : null
     } : null,
-    openIdConnectUrl: Option6.getOrNull(scheme.openIdConnectUrl)
+    openIdConnectUrl: Option5.getOrNull(scheme.openIdConnectUrl)
   })),
   authStrategies: preview.authStrategies,
   headerPresets: preview.headerPresets,
@@ -1256,9 +1274,9 @@ var staticPreviewOutput = (preview) => ({
     label: preset.label,
     securitySchemeName: preset.securitySchemeName,
     flow: preset.flow,
-    authorizationUrl: Option6.getOrNull(preset.authorizationUrl),
+    authorizationUrl: Option5.getOrNull(preset.authorizationUrl),
     tokenUrl: preset.tokenUrl,
-    refreshUrl: Option6.getOrNull(preset.refreshUrl),
+    refreshUrl: Option5.getOrNull(preset.refreshUrl),
     scopes: preset.scopes,
     identityScopes: preset.identityScopes
   }))
@@ -1344,6 +1362,7 @@ var openApiPlugin = definePlugin((options) => {
           } : derivedAuthenticationTemplate && derivedAuthenticationTemplate.length > 0 ? { authenticationTemplate: derivedAuthenticationTemplate } : {}
         };
         yield* ctx.storage.putSpec(specHash, resolved.specText);
+        yield* ctx.storage.putDefs(specHash, JSON.stringify(compiled.hoistedDefs));
         yield* ctx.transaction(
           Effect4.gen(function* () {
             yield* ctx.core.integrations.register({
@@ -1382,6 +1401,7 @@ var openApiPlugin = definePlugin((options) => {
         const nextNames = new Set(compiled.definitions.map((def) => def.toolPath));
         const specHash = yield* sha256Hex(resolved.specText);
         yield* ctx.storage.putSpec(specHash, resolved.specText);
+        yield* ctx.storage.putDefs(specHash, JSON.stringify(compiled.hoistedDefs));
         const nextConfig = {
           ...current,
           specHash,
@@ -1543,7 +1563,7 @@ var openApiPlugin = definePlugin((options) => {
     // operation bindings invokeTool needs are persisted at addSpec time; this
     // hook only shapes the per-connection ToolDefs from the spec blob the
     // catalog config points at.
-    resolveTools: ({ config, storage }) => resolveOpenApiBackedTools({ config, storage }),
+    resolveTools: ({ integration, config, storage }) => resolveOpenApiBackedTools({ integration, config, storage }),
     invokeTool: ({ ctx: invokeCtx, toolRow, credential, args }) => {
       const httpClientLayer = options?.httpClientLayer ?? invokeCtx.httpClientLayer;
       return invokeOpenApiBackedTool({
@@ -1571,7 +1591,7 @@ var openApiPlugin = definePlugin((options) => {
         try: () => new URL(trimmed),
         catch: (error) => error
       }).pipe(Effect4.option);
-      if (Option6.isNone(parsed)) return null;
+      if (Option5.isNone(parsed)) return null;
       const specText = yield* resolveSpecText(trimmed).pipe(
         Effect4.provide(httpClientLayer),
         Effect4.catch(() => Effect4.succeed(null))
@@ -1581,8 +1601,8 @@ var openApiPlugin = definePlugin((options) => {
       if (!doc) return null;
       const result = yield* extract(doc).pipe(Effect4.catch(() => Effect4.succeed(null)));
       if (!result) return null;
-      const slug = Option6.getOrElse(result.title, () => "api").toLowerCase().replace(/[^a-z0-9]+/g, "_");
-      const name = Option6.getOrElse(result.title, () => slug);
+      const slug = Option5.getOrElse(result.title, () => "api").toLowerCase().replace(/[^a-z0-9]+/g, "_");
+      const name = Option5.getOrElse(result.title, () => slug);
       return IntegrationDetectionResult.make({
         kind: "openapi",
         confidence: "high",
@@ -1609,10 +1629,14 @@ export {
   compileOpenApiSpec,
   openApiToolDefsFromCompiled,
   openApiStoredOperationsFromCompiled,
+  buildDefsJsonStreaming,
+  compileAndPersistOpenApiOperations,
+  compileAndPersistOpenApiSpec,
+  compileAndPersistOpenApiSpecStreaming,
   loadOpenApiSpecText,
   resolveOpenApiBackedTools,
   invokeOpenApiBackedTool,
   resolveOpenApiBackedAnnotations,
   openApiPlugin
 };
-//# sourceMappingURL=chunk-UEKOP6NZ.js.map
+//# sourceMappingURL=chunk-ELCKZJE4.js.map