@executor-js/plugin-openapi 1.5.16 → 1.5.18

package/dist/{chunk-KVPUDOJZ.js → chunk-R3X27XS6.js}

@@ -103,12 +103,219 @@ var parseTextToObject = (text) => Effect.gen(function* () {
 });
 var parseJsonText = Schema2.decodeUnknownEffect(Schema2.fromJsonString(Schema2.Unknown));
 var parseJsonLike = (text) => {
-  const parseYaml = Effect.try({
+  const parseYaml2 = Effect.try({
     try: () => parseYamlDocument(text, { json: true, schema: JSON_SCHEMA }),
     catch: () => "YamlParseFailed"
   });
-  if (!text.startsWith("{") && !text.startsWith("[")) return parseYaml;
-  return parseJsonText(text).pipe(Effect.catch(() => parseYaml));
+  if (!text.startsWith("{") && !text.startsWith("[")) return parseYaml2;
+  return parseJsonText(text).pipe(Effect.catch(() => parseYaml2));
+};
+
+// src/sdk/split.ts
+import { JSON_SCHEMA as JSON_SCHEMA2, load as parseYamlDocument2 } from "js-yaml";
+var SPACE = 32;
+var HASH = 35;
+var DASH = 45;
+var SMALL_COMPONENT_SECTIONS = /* @__PURE__ */ new Set([
+  "parameters",
+  "requestBodies",
+  "responses",
+  "headers",
+  "links",
+  "securitySchemes"
+]);
+var indentOf = (text, lineStart, lineEnd) => {
+  let i = lineStart;
+  while (i < lineEnd && text.charCodeAt(i) === SPACE) i++;
+  return i - lineStart;
+};
+var isBlankOrComment = (text, contentStart, lineEnd) => contentStart >= lineEnd || text.charCodeAt(contentStart) === HASH;
+var opensBlockScalar = (line) => /:\s*[|>][+-]?\d*\s*(#.*)?$/.test(line) || /^\s*[|>][+-]?\d*\s*(#.*)?$/.test(line);
+var lineAt = (text, from, limit) => {
+  if (from >= limit) return null;
+  let lineEnd = text.indexOf("\n", from);
+  if (lineEnd === -1 || lineEnd > limit) lineEnd = limit;
+  const indent = indentOf(text, from, lineEnd);
+  const contentStart = from + indent;
+  return {
+    lineStart: from,
+    lineEnd,
+    nextStart: lineEnd + 1,
+    indent,
+    contentStart
+  };
+};
+var keyLineStartsAtIndent = (text, start, end, indent) => {
+  const starts = [];
+  let blockScalarIndent = -1;
+  let pos = start;
+  while (pos < end) {
+    const line = lineAt(text, pos, end);
+    if (!line) break;
+    pos = line.nextStart;
+    if (isBlankOrComment(text, line.contentStart, line.lineEnd)) continue;
+    if (blockScalarIndent >= 0) {
+      if (line.indent > blockScalarIndent) continue;
+      blockScalarIndent = -1;
+    }
+    if (line.indent === indent && text.charCodeAt(line.contentStart) !== DASH) {
+      starts.push(line.lineStart);
+    }
+    if (line.indent <= indent && opensBlockScalar(text.slice(line.contentStart, line.lineEnd))) {
+      blockScalarIndent = line.indent;
+    }
+  }
+  return starts;
+};
+var rangesFromStarts = (starts, blockEnd) => starts.map((s, i) => ({ start: s, end: i + 1 < starts.length ? starts[i + 1] : blockEnd }));
+var keyNameAt = (text, lineStart, lineEnd) => {
+  const indent = indentOf(text, lineStart, lineEnd);
+  const colon = text.indexOf(":", lineStart + indent);
+  const keyEnd = colon === -1 || colon > lineEnd ? lineEnd : colon;
+  return text.slice(lineStart + indent, keyEnd).trim();
+};
+var structuralSplit = (text) => {
+  const len = text.length;
+  const topStarts = [];
+  const topNames = [];
+  {
+    let blockScalarIndent = -1;
+    let pos = 0;
+    while (pos < len) {
+      const line = lineAt(text, pos, len);
+      if (!line) break;
+      pos = line.nextStart;
+      if (isBlankOrComment(text, line.contentStart, line.lineEnd)) continue;
+      if (blockScalarIndent >= 0) {
+        if (line.indent > blockScalarIndent) continue;
+        blockScalarIndent = -1;
+      }
+      if (line.indent === 0) {
+        topStarts.push(line.lineStart);
+        topNames.push(keyNameAt(text, line.lineStart, line.lineEnd));
+      }
+      if (opensBlockScalar(text.slice(line.contentStart, line.lineEnd))) {
+        blockScalarIndent = line.indent;
+      }
+    }
+  }
+  const topRanges = rangesFromStarts(topStarts, len);
+  const pathsIdx = topNames.indexOf("paths");
+  if (pathsIdx === -1) return null;
+  const componentsIdx = topNames.indexOf("components");
+  const headRanges = [];
+  for (let i = 0; i < topRanges.length; i++) {
+    if (i === pathsIdx || i === componentsIdx) continue;
+    headRanges.push(topRanges[i]);
+  }
+  const pathsRange = topRanges[pathsIdx];
+  const pathsBodyStart = lineAt(text, pathsRange.start, pathsRange.end)?.nextStart ?? pathsRange.end;
+  const pathItems = rangesFromStarts(
+    keyLineStartsAtIndent(text, pathsBodyStart, pathsRange.end, 2),
+    pathsRange.end
+  );
+  const schemas = [];
+  const smallComponentRanges = [];
+  if (componentsIdx !== -1) {
+    const componentsRange = topRanges[componentsIdx];
+    const componentsBodyStart = lineAt(text, componentsRange.start, componentsRange.end)?.nextStart ?? componentsRange.end;
+    const subStarts = keyLineStartsAtIndent(text, componentsBodyStart, componentsRange.end, 2);
+    const subRanges = rangesFromStarts(subStarts, componentsRange.end);
+    for (const range of subRanges) {
+      const name = keyNameAt(text, range.start, lineAt(text, range.start, range.end).lineEnd);
+      if (name === "schemas") {
+        const bodyStart = lineAt(text, range.start, range.end)?.nextStart ?? range.end;
+        for (const s of rangesFromStarts(
+          keyLineStartsAtIndent(text, bodyStart, range.end, 4),
+          range.end
+        )) {
+          schemas.push(s);
+        }
+      } else if (SMALL_COMPONENT_SECTIONS.has(name)) {
+        smallComponentRanges.push(range);
+      }
+    }
+  }
+  return { text, headRanges, pathItems, schemas, smallComponentRanges };
+};
+var dedent = (fragment, indent) => indent === 0 ? fragment : fragment.replace(new RegExp(`^ {1,${indent}}`, "gm"), "");
+var parseYaml = (text) => parseYamlDocument2(text, { json: true, schema: JSON_SCHEMA2 });
+var parseEntry = (text, range, indent) => {
+  const parsed = parseYaml(dedent(text.slice(range.start, range.end), indent));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const entries = Object.entries(parsed);
+  if (entries.length !== 1) return null;
+  return entries[0];
+};
+var parseHead = (structure) => {
+  const text = structure.headRanges.map((r) => structure.text.slice(r.start, r.end)).join("");
+  const parsed = parseYaml(text);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+};
+var parseSmallComponents = (structure) => {
+  if (structure.smallComponentRanges.length === 0) return {};
+  const body = structure.smallComponentRanges.map((r) => structure.text.slice(r.start, r.end)).join("");
+  const parsed = parseYaml(`components:
+${body}`);
+  const components = parsed && typeof parsed === "object" ? parsed.components : null;
+  return components && typeof components === "object" ? components : {};
+};
+var isStreamableSpec = (text) => {
+  if (text.indexOf("	") !== -1) return false;
+  if (/(^|\s)[&*][A-Za-z0-9_]/m.test(text)) return false;
+  if (/<<\s*:/.test(text)) return false;
+  return /^paths:/m.test(text);
+};
+var SCHEMA_REF_PREFIX = "#/components/schemas/";
+var indexSchemas = (structure) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const range of structure.schemas) {
+    const line = lineAt(structure.text, range.start, range.end);
+    if (!line) continue;
+    const name = keyNameAt(structure.text, range.start, line.lineEnd);
+    if (name) index.set(name, range);
+  }
+  return index;
+};
+var decodeSchemaRefName = (segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~");
+var collectSchemaRefNames = (value, into) => {
+  if (typeof value === "string") {
+    if (value.startsWith(SCHEMA_REF_PREFIX)) {
+      const name = decodeSchemaRefName(value.slice(SCHEMA_REF_PREFIX.length));
+      if (name.length > 0) into.add(name);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectSchemaRefNames(item, into);
+    return;
+  }
+  if (value !== null && typeof value === "object") {
+    for (const item of Object.values(value)) {
+      collectSchemaRefNames(item, into);
+    }
+  }
+};
+var collectReferencedSchemas = (structure, index, roots) => {
+  const result = {};
+  const wanted = /* @__PURE__ */ new Set();
+  for (const root of roots) collectSchemaRefNames(root, wanted);
+  const queue = [...wanted];
+  for (let i = 0; i < queue.length; i += 1) {
+    const name = queue[i];
+    if (Object.prototype.hasOwnProperty.call(result, name)) continue;
+    const range = index.get(name);
+    if (!range) continue;
+    const entry = parseEntry(structure.text, range, 4);
+    if (!entry) continue;
+    result[name] = entry[1];
+    const next = /* @__PURE__ */ new Set();
+    collectSchemaRefNames(entry[1], next);
+    for (const ref of next) {
+      if (!Object.prototype.hasOwnProperty.call(result, ref)) queue.push(ref);
+    }
+  }
+  return result;
 };
 
 // src/sdk/openapi-utils.ts
@@ -290,7 +497,162 @@ var InvocationResult = Schema3.Struct({
 });
 
 // src/sdk/extract.ts
-import { Effect as Effect2, Option } from "effect";
+import { Effect as Effect2, Option as Option2 } from "effect";
+
+// src/sdk/definitions.ts
+import { Option } 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
+  }));
+};
+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 planToolPaths = (inputs) => {
+  const raw = inputs.map((op, index) => {
+    const operationId = op.operationId;
+    const operationHash = stableHash({
+      method: op.method,
+      path: op.pathTemplate,
+      operationId
+    });
+    const versionSegment = deriveVersionSegment(op.pathTemplate);
+    if (op.explicitToolPath) {
+      const [group2 = "root", ...leafParts] = op.explicitToolPath.split(".").filter(Boolean);
+      const leaf2 = leafParts.join(".") || group2;
+      return {
+        toolPath: op.explicitToolPath,
+        group: group2,
+        leaf: leaf2,
+        versionSegment,
+        method: op.method,
+        operationHash,
+        operationIndex: index
+      };
+    }
+    const group = normalizeGroupSegment(op.tag0) ?? derivePathGroup(op.pathTemplate);
+    const leaf = deriveLeaf(operationId, op.method, op.pathTemplate, group);
+    return {
+      toolPath: `${group}.${leaf}`,
+      group,
+      leaf,
+      versionSegment,
+      method: op.method,
+      operationHash,
+      operationIndex: index
+    };
+  });
+  return resolveCollisions(raw).sort((a, b) => a.toolPath.localeCompare(b.toolPath));
+};
+var compileToolDefinitions = (operations) => {
+  const plans = planToolPaths(
+    operations.map((op) => ({
+      operationId: op.operationId,
+      explicitToolPath: Option.getOrUndefined(op.toolPath),
+      method: op.method,
+      pathTemplate: op.pathTemplate,
+      tag0: op.tags[0]
+    }))
+  );
+  return plans.map((plan) => ({
+    toolPath: plan.toolPath,
+    group: plan.group,
+    leaf: plan.leaf,
+    operationIndex: plan.operationIndex,
+    operation: operations[plan.operationIndex]
+  }));
+};
+
+// src/sdk/extract.ts
 var HTTP_METHODS = [
   "get",
   "put",
@@ -319,11 +681,11 @@ var extractParameters = (pathItem, operation, r) => {
       name: p.name,
       location: p.in,
       required: p.in === "path" ? true : p.required === true,
-      schema: Option.fromNullishOr(p.schema),
-      style: Option.fromNullishOr(p.style),
-      explode: Option.fromNullishOr(p.explode),
-      allowReserved: Option.fromNullishOr("allowReserved" in p ? p.allowReserved : void 0),
-      description: Option.fromNullishOr(p.description)
+      schema: Option2.fromNullishOr(p.schema),
+      style: Option2.fromNullishOr(p.style),
+      explode: Option2.fromNullishOr(p.explode),
+      allowReserved: Option2.fromNullishOr("allowReserved" in p ? p.allowReserved : void 0),
+      description: Option2.fromNullishOr(p.description)
     })
   );
 };
@@ -334,10 +696,10 @@ var buildEncodingRecord = (encoding) => {
     if (typeof raw !== "object" || raw === null) continue;
     const e = raw;
     out[prop] = EncodingObject.make({
-      contentType: Option.fromNullishOr(e.contentType),
-      style: Option.fromNullishOr(e.style),
-      explode: Option.fromNullishOr(e.explode),
-      allowReserved: Option.fromNullishOr(e.allowReserved)
+      contentType: Option2.fromNullishOr(e.contentType),
+      style: Option2.fromNullishOr(e.style),
+      explode: Option2.fromNullishOr(e.explode),
+      allowReserved: Option2.fromNullishOr(e.allowReserved)
     });
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -349,8 +711,8 @@ var extractRequestBody = (operation, r) => {
   const contents = declaredContents(body.content).map(
     ({ mediaType, media }) => MediaBinding.make({
       contentType: mediaType,
-      schema: Option.fromNullishOr(media.schema),
-      encoding: Option.fromNullishOr(
+      schema: Option2.fromNullishOr(media.schema),
+      encoding: Option2.fromNullishOr(
         buildEncodingRecord(media.encoding)
       )
     })
@@ -361,7 +723,7 @@ var extractRequestBody = (operation, r) => {
     required: body.required === true,
     contentType: defaultContent.contentType,
     schema: defaultContent.schema,
-    contents: Option.some(contents)
+    contents: Option2.some(contents)
   });
 };
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -380,10 +742,10 @@ var detectFileHint = (schema, mediaType, r) => {
   if (!isJsonMediaType(mediaType) && binaryStringSchema(resolved)) {
     return OperationFileHint.make({
       kind: "binaryResponse",
-      mimeType: Option.some(mediaType),
-      dataField: Option.none(),
-      sizeField: Option.none(),
-      encoding: Option.none()
+      mimeType: Option2.some(mediaType),
+      dataField: Option2.none(),
+      sizeField: Option2.none(),
+      encoding: Option2.none()
     });
   }
   if (!isJsonMediaType(mediaType)) return void 0;
@@ -397,10 +759,10 @@ var detectFileHint = (schema, mediaType, r) => {
   const sizeField = sizeSchema && numericType(sizeSchema) ? "size" : void 0;
   return OperationFileHint.make({
     kind: "byteField",
-    mimeType: Option.some("application/octet-stream"),
-    dataField: Option.some("data"),
-    sizeField: sizeField ? Option.some(sizeField) : Option.none(),
-    encoding: Option.some(base64EncodingFromDescription(dataSchema))
+    mimeType: Option2.some("application/octet-stream"),
+    dataField: Option2.some("data"),
+    sizeField: sizeField ? Option2.some(sizeField) : Option2.none(),
+    encoding: Option2.some(base64EncodingFromDescription(dataSchema))
   });
 };
 var extractResponseBody = (operation, r) => {
@@ -417,8 +779,8 @@ var extractResponseBody = (operation, r) => {
     if (content?.media.schema) {
       return OperationResponseBody.make({
         contentType: content.mediaType,
-        schema: Option.some(content.media.schema),
-        fileHint: Option.fromNullishOr(detectFileHint(content.media.schema, content.mediaType, r))
+        schema: Option2.some(content.media.schema),
+        fileHint: Option2.fromNullishOr(detectFileHint(content.media.schema, content.mediaType, r))
       });
     }
   }
@@ -427,7 +789,7 @@ var extractResponseBody = (operation, r) => {
 var buildServerInputProperty = (servers) => {
   const variableDefs = {};
   for (const server of servers) {
-    for (const [name, v] of Object.entries(Option.getOrUndefined(server.variables) ?? {})) {
+    for (const [name, v] of Object.entries(Option2.getOrUndefined(server.variables) ?? {})) {
       if (!(name in variableDefs)) variableDefs[name] = v;
     }
   }
@@ -453,8 +815,8 @@ var buildServerInputProperty = (servers) => {
           {
             type: "string",
             default: v.default,
-            ...Option.isSome(v.enum) ? { enum: v.enum.value } : {},
-            ...Option.isSome(v.description) ? { description: v.description.value } : {}
+            ...Option2.isSome(v.enum) ? { enum: v.enum.value } : {},
+            ...Option2.isSome(v.description) ? { description: v.description.value } : {}
           }
         ])
       ),
@@ -472,15 +834,15 @@ var buildInputSchema = (parameters, requestBody, servers) => {
   const properties = {};
   const required = [];
   for (const param of parameters) {
-    properties[param.name] = Option.getOrElse(param.schema, () => ({ type: "string" }));
+    properties[param.name] = Option2.getOrElse(param.schema, () => ({ type: "string" }));
     if (param.required) required.push(param.name);
   }
   const serverProperty = buildServerInputProperty(servers);
   if (serverProperty && !("server" in properties)) properties.server = serverProperty;
   if (requestBody) {
-    properties.body = Option.getOrElse(requestBody.schema, () => ({ type: "object" }));
+    properties.body = Option2.getOrElse(requestBody.schema, () => ({ type: "object" }));
     if (requestBody.required) required.push("body");
-    const contents = Option.getOrUndefined(requestBody.contents);
+    const contents = Option2.getOrUndefined(requestBody.contents);
     if (contents && contents.length > 1) {
       properties.contentType = {
         type: "string",
@@ -519,8 +881,8 @@ var extractServerList = (servers) => (servers ?? []).flatMap((server) => {
           name,
           ServerVariable.make({
             default: String(v.default),
-            enum: enumValues && enumValues.length > 0 ? Option.some(enumValues) : Option.none(),
-            description: Option.fromNullishOr(v.description)
+            enum: enumValues && enumValues.length > 0 ? Option2.some(enumValues) : Option2.none(),
+            description: Option2.fromNullishOr(v.description)
           })
         ]
       ];
@@ -529,8 +891,8 @@ var extractServerList = (servers) => (servers ?? []).flatMap((server) => {
   return [
     ServerInfo.make({
       url: server.url,
-      description: Option.fromNullishOr(server.description),
-      variables: vars && Object.keys(vars).length > 0 ? Option.some(vars) : Option.none()
+      description: Option2.fromNullishOr(server.description),
+      variables: vars && Object.keys(vars).length > 0 ? Option2.some(vars) : Option2.none()
     })
   ];
 });
@@ -564,40 +926,177 @@ var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
       const responseBody = extractResponseBody(operation, r);
       const servers = operationServers(pathItem, operation, docServers);
       const inputSchema = buildInputSchema(parameters, requestBody, servers);
-      const outputSchema = responseBody ? Option.getOrUndefined(responseBody.schema) : void 0;
+      const outputSchema = responseBody ? Option2.getOrUndefined(responseBody.schema) : void 0;
       const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);
       const operationPathTemplate = explicitPathTemplate(operation) ?? pathTemplate;
       operations.push(
         ExtractedOperation.make({
           operationId: OperationId.make(deriveOperationId(method, pathTemplate, operation)),
-          toolPath: Option.fromNullishOr(explicitToolPath(operation)),
+          toolPath: Option2.fromNullishOr(explicitToolPath(operation)),
           method,
           servers,
           pathTemplate: operationPathTemplate,
-          summary: Option.fromNullishOr(operation.summary),
-          description: Option.fromNullishOr(operation.description),
+          summary: Option2.fromNullishOr(operation.summary),
+          description: Option2.fromNullishOr(operation.description),
           tags,
           parameters,
-          requestBody: Option.fromNullishOr(requestBody),
-          responseBody: Option.fromNullishOr(responseBody),
-          inputSchema: Option.fromNullishOr(inputSchema),
-          outputSchema: Option.fromNullishOr(outputSchema),
+          requestBody: Option2.fromNullishOr(requestBody),
+          responseBody: Option2.fromNullishOr(responseBody),
+          inputSchema: Option2.fromNullishOr(inputSchema),
+          outputSchema: Option2.fromNullishOr(outputSchema),
           deprecated: operation.deprecated === true
         })
       );
     }
   }
   return ExtractionResult.make({
-    title: Option.fromNullishOr(doc.info?.title),
-    description: Option.fromNullishOr(doc.info?.description),
-    version: Option.fromNullishOr(doc.info?.version),
+    title: Option2.fromNullishOr(doc.info?.title),
+    description: Option2.fromNullishOr(doc.info?.description),
+    version: Option2.fromNullishOr(doc.info?.version),
     servers: docServers,
     operations
   });
 });
+var streamOperationBindings = (doc, chunkSize, onChunk) => Effect2.gen(function* () {
+  const paths = doc.paths;
+  if (!paths) {
+    return yield* new OpenApiExtractionError({
+      message: "OpenAPI document has no paths defined"
+    });
+  }
+  const r = new DocResolver(doc);
+  const docServers = extractServers(doc);
+  const inputs = [];
+  const opRefs = [];
+  for (const [pathTemplate, pathItem] of Object.entries(paths).sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    if (!pathItem) continue;
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const resolvedPathTemplate = explicitPathTemplate(operation) ?? pathTemplate;
+      const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);
+      inputs.push({
+        operationId: deriveOperationId(method, pathTemplate, operation),
+        explicitToolPath: explicitToolPath(operation),
+        method,
+        pathTemplate: resolvedPathTemplate,
+        tag0: tags[0]
+      });
+      opRefs.push({ pathItem, operation, method, pathTemplate: resolvedPathTemplate });
+    }
+  }
+  const plans = planToolPaths(inputs);
+  let chunk = [];
+  for (const plan of plans) {
+    const ref = opRefs[plan.operationIndex];
+    const parameters = extractParameters(ref.pathItem, ref.operation, r);
+    const requestBody = extractRequestBody(ref.operation, r);
+    const responseBody = extractResponseBody(ref.operation, r);
+    const servers = operationServers(ref.pathItem, ref.operation, docServers);
+    chunk.push({
+      toolName: plan.toolPath,
+      description: ref.operation.description ?? ref.operation.summary ?? `${ref.method.toUpperCase()} ${ref.pathTemplate}`,
+      binding: OperationBinding.make({
+        method: ref.method,
+        servers,
+        pathTemplate: ref.pathTemplate,
+        parameters,
+        requestBody: Option2.fromNullishOr(requestBody),
+        responseBody: Option2.fromNullishOr(responseBody)
+      })
+    });
+    if (chunk.length >= chunkSize) {
+      yield* onChunk(chunk);
+      chunk = [];
+    }
+  }
+  if (chunk.length > 0) yield* onChunk(chunk);
+  return { toolCount: plans.length, toolNames: plans.map((plan) => plan.toolPath) };
+}).pipe(Effect2.withSpan("OpenApi.streamOperationBindings"));
+var isPathItemValue = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var streamOperationBindingsFromStructure = (structure, options, onChunk) => Effect2.gen(function* () {
+  const { chunkSize, keepPathItem } = options;
+  const keptPathItem = (range) => {
+    const entry = parseEntry(structure.text, range, 2);
+    if (!entry) return null;
+    const [path, rawValue] = entry;
+    if (!isPathItemValue(rawValue)) return null;
+    if (!keepPathItem) return [path, rawValue];
+    const kept = keepPathItem(path, rawValue);
+    return kept ? [path, kept] : null;
+  };
+  const inputs = [];
+  for (const range of structure.pathItems) {
+    const kept = keptPathItem(range);
+    if (!kept) continue;
+    const [path, pathItem] = kept;
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const resolvedPathTemplate = explicitPathTemplate(operation) ?? path;
+      const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);
+      inputs.push({
+        operationId: deriveOperationId(method, path, operation),
+        explicitToolPath: explicitToolPath(operation),
+        method,
+        pathTemplate: resolvedPathTemplate,
+        tag0: tags[0]
+      });
+    }
+  }
+  const plans = planToolPaths(inputs);
+  const planByOpIndex = new Array(inputs.length);
+  for (const plan of plans) planByOpIndex[plan.operationIndex] = plan;
+  const resolverDoc = {
+    ...parseHead(structure),
+    paths: {},
+    components: parseSmallComponents(structure)
+  };
+  const r = new DocResolver(resolverDoc);
+  const docServers = extractServers(resolverDoc);
+  let opIndex = 0;
+  let chunk = [];
+  for (const range of structure.pathItems) {
+    const kept = keptPathItem(range);
+    if (!kept) continue;
+    const [path, pathItem] = kept;
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const plan = planByOpIndex[opIndex];
+      opIndex += 1;
+      if (!plan) continue;
+      const resolvedPathTemplate = explicitPathTemplate(operation) ?? path;
+      const parameters = extractParameters(pathItem, operation, r);
+      const requestBody = extractRequestBody(operation, r);
+      const responseBody = extractResponseBody(operation, r);
+      const servers = operationServers(pathItem, operation, docServers);
+      chunk.push({
+        toolName: plan.toolPath,
+        description: operation.description ?? operation.summary ?? `${method.toUpperCase()} ${resolvedPathTemplate}`,
+        binding: OperationBinding.make({
+          method,
+          servers,
+          pathTemplate: resolvedPathTemplate,
+          parameters,
+          requestBody: Option2.fromNullishOr(requestBody),
+          responseBody: Option2.fromNullishOr(responseBody)
+        })
+      });
+      if (chunk.length >= chunkSize) {
+        yield* onChunk(chunk);
+        chunk = [];
+      }
+    }
+  }
+  if (chunk.length > 0) yield* onChunk(chunk);
+  return { toolCount: plans.length, toolNames: plans.map((plan) => plan.toolPath) };
+}).pipe(Effect2.withSpan("OpenApi.streamOperationBindingsFromStructure"));
 
 // src/sdk/preview.ts
-import { Effect as Effect3, Option as Option2, Predicate } from "effect";
+import { Effect as Effect3, Option as Option3, Predicate } from "effect";
 import { Schema as Schema4 } from "effect";
 var OAuth2Scopes = Schema4.Record(Schema4.String, Schema4.String);
 var SecuritySchemeType = Schema4.Literals(["http", "apiKey", "oauth2", "openIdConnect"]);
@@ -718,21 +1217,21 @@ var stringRecord = (value) => {
   return out;
 };
 var extractFlows = (rawFlows) => {
-  if (!rawFlows || typeof rawFlows !== "object") return Option2.none();
+  if (!rawFlows || typeof rawFlows !== "object") return Option3.none();
   const flows = rawFlows;
   const parseFlow = (key) => flows[key];
-  let authorizationCode = Option2.none();
+  let authorizationCode = Option3.none();
   const authCodeRaw = parseFlow("authorizationCode");
   if (authCodeRaw && typeof authCodeRaw === "object") {
     const f = authCodeRaw;
     const authUrl = typeof f.authorizationUrl === "string" ? f.authorizationUrl : null;
     const tokenUrl = typeof f.tokenUrl === "string" ? f.tokenUrl : null;
     if (authUrl && tokenUrl) {
-      authorizationCode = Option2.some(
+      authorizationCode = Option3.some(
         OAuth2AuthorizationCodeFlow.make({
           authorizationUrl: authUrl,
           tokenUrl,
-          refreshUrl: Option2.fromNullishOr(
+          refreshUrl: Option3.fromNullishOr(
             typeof f.refreshUrl === "string" ? f.refreshUrl : void 0
           ),
           scopes: stringRecord(f.scopes)
@@ -740,16 +1239,16 @@ var extractFlows = (rawFlows) => {
       );
     }
   }
-  let clientCredentials = Option2.none();
+  let clientCredentials = Option3.none();
   const ccRaw = parseFlow("clientCredentials");
   if (ccRaw && typeof ccRaw === "object") {
     const f = ccRaw;
     const tokenUrl = typeof f.tokenUrl === "string" ? f.tokenUrl : null;
     if (tokenUrl) {
-      clientCredentials = Option2.some(
+      clientCredentials = Option3.some(
         OAuth2ClientCredentialsFlow.make({
           tokenUrl,
-          refreshUrl: Option2.fromNullishOr(
+          refreshUrl: Option3.fromNullishOr(
             typeof f.refreshUrl === "string" ? f.refreshUrl : void 0
           ),
           scopes: stringRecord(f.scopes)
@@ -757,10 +1256,10 @@ var extractFlows = (rawFlows) => {
       );
     }
   }
-  if (Option2.isNone(authorizationCode) && Option2.isNone(clientCredentials)) {
-    return Option2.none();
+  if (Option3.isNone(authorizationCode) && Option3.isNone(clientCredentials)) {
+    return Option3.none();
   }
-  return Option2.some(OAuth2Flows.make({ authorizationCode, clientCredentials }));
+  return Option3.some(OAuth2Flows.make({ authorizationCode, clientCredentials }));
 };
 var extractSecuritySchemes = (rawSchemes, resolver) => Object.entries(rawSchemes).flatMap(([name, schemeOrRef]) => {
   if (!schemeOrRef || typeof schemeOrRef !== "object") return [];
@@ -770,19 +1269,19 @@ var extractSecuritySchemes = (rawSchemes, resolver) => Object.entries(rawSchemes
   if (!resolved || typeof resolved !== "object") return [];
   const scheme = resolved;
   const type = decodeSecuritySchemeType(scheme.type);
-  if (Option2.isNone(type)) return [];
+  if (Option3.isNone(type)) return [];
   const schemeType = type.value;
   return [
     SecurityScheme.make({
       name,
       type: schemeType,
-      scheme: Option2.fromNullishOr(scheme.scheme),
-      bearerFormat: Option2.fromNullishOr(scheme.bearerFormat),
-      in: Option2.fromNullishOr(scheme.in),
-      headerName: Option2.fromNullishOr(scheme.name),
-      description: Option2.fromNullishOr(scheme.description),
-      flows: schemeType === "oauth2" ? extractFlows(scheme.flows) : Option2.none(),
-      openIdConnectUrl: Option2.fromNullishOr(scheme.openIdConnectUrl)
+      scheme: Option3.fromNullishOr(scheme.scheme),
+      bearerFormat: Option3.fromNullishOr(scheme.bearerFormat),
+      in: Option3.fromNullishOr(scheme.in),
+      headerName: Option3.fromNullishOr(scheme.name),
+      description: Option3.fromNullishOr(scheme.description),
+      flows: schemeType === "oauth2" ? extractFlows(scheme.flows) : Option3.none(),
+      openIdConnectUrl: Option3.fromNullishOr(scheme.openIdConnectUrl)
     })
   ];
 });
@@ -795,21 +1294,21 @@ var buildHeaderPresets = (schemes, strategies) => {
     const secretHeaders = [];
     const labelParts = [];
     for (const scheme of resolved) {
-      if (scheme.type === "http" && Option2.getOrElse(scheme.scheme, () => "") === "bearer") {
+      if (scheme.type === "http" && Option3.getOrElse(scheme.scheme, () => "") === "bearer") {
         headers["Authorization"] = null;
         secretHeaders.push("Authorization");
         labelParts.push("Bearer Token");
-      } else if (scheme.type === "http" && Option2.getOrElse(scheme.scheme, () => "") === "basic") {
+      } else if (scheme.type === "http" && Option3.getOrElse(scheme.scheme, () => "") === "basic") {
         headers["Authorization"] = null;
         secretHeaders.push("Authorization");
         labelParts.push("Basic Auth");
-      } else if (scheme.type === "apiKey" && Option2.getOrElse(scheme.in, () => "") === "header") {
-        const headerName = Option2.getOrElse(scheme.headerName, () => scheme.name);
+      } else if (scheme.type === "apiKey" && Option3.getOrElse(scheme.in, () => "") === "header") {
+        const headerName = Option3.getOrElse(scheme.headerName, () => scheme.name);
         headers[headerName] = null;
         secretHeaders.push(headerName);
         labelParts.push(scheme.name);
       } else if (scheme.type === "apiKey") {
-        labelParts.push(`${scheme.name} (${Option2.getOrElse(scheme.in, () => "unknown")})`);
+        labelParts.push(`${scheme.name} (${Option3.getOrElse(scheme.in, () => "unknown")})`);
       } else if (scheme.type === "oauth2" || scheme.type === "openIdConnect") {
         return [];
       } else {
@@ -838,16 +1337,16 @@ var buildOAuth2Presets = (schemes) => {
   const presets = [];
   for (const scheme of schemes) {
     if (scheme.type !== "oauth2") continue;
-    if (Option2.isNone(scheme.flows)) continue;
+    if (Option3.isNone(scheme.flows)) continue;
     const flows = scheme.flows.value;
-    if (Option2.isSome(flows.authorizationCode)) {
+    if (Option3.isSome(flows.authorizationCode)) {
       const flow = flows.authorizationCode.value;
       presets.push(
         OAuth2Preset.make({
           label: `OAuth2 Authorization Code \xB7 ${scheme.name}`,
           securitySchemeName: scheme.name,
           flow: "authorizationCode",
-          authorizationUrl: Option2.some(flow.authorizationUrl),
+          authorizationUrl: Option3.some(flow.authorizationUrl),
           tokenUrl: flow.tokenUrl,
           refreshUrl: flow.refreshUrl,
           scopes: flow.scopes,
@@ -855,14 +1354,14 @@ var buildOAuth2Presets = (schemes) => {
         })
       );
     }
-    if (Option2.isSome(flows.clientCredentials)) {
+    if (Option3.isSome(flows.clientCredentials)) {
       const flow = flows.clientCredentials.value;
       presets.push(
         OAuth2Preset.make({
           label: `OAuth2 Client Credentials \xB7 ${scheme.name}`,
           securitySchemeName: scheme.name,
           flow: "clientCredentials",
-          authorizationUrl: Option2.none(),
+          authorizationUrl: Option3.none(),
           tokenUrl: flow.tokenUrl,
           refreshUrl: flow.refreshUrl,
           scopes: flow.scopes,
@@ -927,6 +1426,14 @@ export {
   fetchSpecText,
   resolveSpecText,
   parse,
+  compileToolDefinitions,
+  structuralSplit,
+  parseEntry,
+  parseHead,
+  parseSmallComponents,
+  isStreamableSpec,
+  indexSchemas,
+  collectReferencedSchemas,
   DocResolver,
   substituteUrlVariables,
   resolveServerUrl,
@@ -946,7 +1453,10 @@ export {
   OperationBinding,
   InvocationResult,
   TOKEN_VARIABLE,
+  buildInputSchema,
   extract,
+  streamOperationBindings,
+  streamOperationBindingsFromStructure,
   OAuth2AuthorizationCodeFlow,
   OAuth2ClientCredentialsFlow,
   OAuth2Flows,
@@ -960,4 +1470,4 @@ export {
   previewSpecText,
   previewSpec
 };
-//# sourceMappingURL=chunk-KVPUDOJZ.js.map
+//# sourceMappingURL=chunk-R3X27XS6.js.map