@executor-js/plugin-openapi 0.0.1 → 0.1.0

package/dist/chunk-KPGROAQO.js

@@ -1,1279 +0,0 @@
-// src/sdk/errors.ts
-import { Data, Schema } from "effect";
-var OpenApiParseError = class extends Schema.TaggedError()(
-  "OpenApiParseError",
-  {
-    message: Schema.String
-  }
-) {
-};
-var OpenApiExtractionError = class extends Schema.TaggedError()(
-  "OpenApiExtractionError",
-  {
-    message: Schema.String
-  }
-) {
-};
-var OpenApiInvocationError = class extends Data.TaggedError("OpenApiInvocationError") {
-};
-
-// src/sdk/parse.ts
-import SwaggerParser from "@apidevtools/swagger-parser";
-import { Effect } from "effect";
-import YAML from "yaml";
-var parse = Effect.fn("OpenApi.parse")(function* (input) {
-  const api = yield* Effect.tryPromise({
-    try: async () => {
-      const source = input.startsWith("http://") || input.startsWith("https://") ? input : parseTextToObject(input);
-      try {
-        return await SwaggerParser.bundle(source);
-      } catch {
-        const parsed = await SwaggerParser.parse(source);
-        resolveRefsInPlace(parsed);
-        return parsed;
-      }
-    },
-    catch: (error) => new OpenApiParseError({
-      message: `Failed to parse OpenAPI document: ${error instanceof Error ? error.message : String(error)}`
-    })
-  });
-  if (!isOpenApi3(api)) {
-    return yield* new OpenApiExtractionErrorFromParse({
-      message: "Only OpenAPI 3.x documents are supported. Swagger 2.x documents should be converted first."
-    });
-  }
-  return api;
-});
-var OpenApiExtractionErrorFromParse = class extends OpenApiExtractionError {
-};
-var isOpenApi3 = (doc) => "openapi" in doc && typeof doc.openapi === "string" && doc.openapi.startsWith("3.");
-var parseTextToObject = (text) => {
-  const trimmed = text.trim();
-  if (trimmed.length === 0) throw new Error("OpenAPI document is empty");
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    parsed = YAML.parse(trimmed);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error("OpenAPI document must parse to an object");
-  }
-  return parsed;
-};
-var resolveRefsInPlace = (doc) => {
-  const lookup = (pointer) => {
-    if (!pointer.startsWith("#/")) return void 0;
-    const parts = pointer.slice(2).split("/");
-    let current = doc;
-    for (const part of parts) {
-      if (typeof current !== "object" || current === null) return void 0;
-      current = current[part];
-    }
-    return current;
-  };
-  const resolving = /* @__PURE__ */ new Set();
-  const resolveRef = (pointer) => {
-    if (resolving.has(pointer)) return void 0;
-    const target = lookup(pointer);
-    if (!target) return void 0;
-    resolving.add(pointer);
-    const cloned = deepClone(target);
-    walk(cloned);
-    resolving.delete(pointer);
-    return cloned;
-  };
-  const deepClone = (obj) => {
-    if (!obj || typeof obj !== "object") return obj;
-    if (Array.isArray(obj)) return obj.map(deepClone);
-    const result = {};
-    for (const [k, v] of Object.entries(obj)) {
-      result[k] = deepClone(v);
-    }
-    return result;
-  };
-  const walk = (obj) => {
-    if (!obj || typeof obj !== "object") return;
-    if (Array.isArray(obj)) {
-      for (let i = 0; i < obj.length; i++) {
-        const item = obj[i];
-        if (isRef(item)) {
-          const resolved = resolveRef(item.$ref);
-          if (resolved) obj[i] = resolved;
-          else obj[i] = { description: `Unresolved: ${item.$ref}` };
-        } else {
-          walk(item);
-        }
-      }
-      return;
-    }
-    const record = obj;
-    for (const [k, v] of Object.entries(record)) {
-      if (k === "$ref") continue;
-      if (isRef(v)) {
-        const resolved = resolveRef(v.$ref);
-        if (resolved) record[k] = resolved;
-        else record[k] = { description: `Unresolved: ${v.$ref}` };
-      } else {
-        walk(v);
-      }
-    }
-  };
-  walk(doc);
-};
-var isRef = (v) => typeof v === "object" && v !== null && "$ref" in v && typeof v.$ref === "string";
-
-// src/sdk/openapi-utils.ts
-import { Option } from "effect";
-var DocResolver = class {
-  constructor(doc) {
-    this.doc = doc;
-  }
-  doc;
-  /** Resolve a value that might be a $ref, returning the resolved object */
-  resolve(value) {
-    if (isRef2(value)) {
-      const resolved = this.resolvePointer(value.$ref);
-      return resolved;
-    }
-    return value;
-  }
-  resolvePointer(ref) {
-    if (!ref.startsWith("#/")) return null;
-    const segments = ref.slice(2).split("/");
-    let current = this.doc;
-    for (const segment of segments) {
-      if (typeof current !== "object" || current === null) return null;
-      current = current[segment];
-    }
-    return current;
-  }
-};
-var isRef2 = (value) => typeof value === "object" && value !== null && "$ref" in value;
-var resolveBaseUrl = (servers) => {
-  const server = servers[0];
-  if (!server) return "";
-  let url = server.url;
-  if (Option.isSome(server.variables)) {
-    for (const [name, value] of Object.entries(server.variables.value)) {
-      url = url.replaceAll(`{${name}}`, value);
-    }
-  }
-  return url;
-};
-var preferredContent = (content) => {
-  if (!content) return void 0;
-  const entries = Object.entries(content);
-  const pick = entries.find(([mt]) => mt === "application/json") ?? entries.find(([mt]) => mt.toLowerCase().includes("+json")) ?? entries.find(([mt]) => mt.toLowerCase().includes("json")) ?? entries[0];
-  return pick ? { mediaType: pick[0], media: pick[1] } : void 0;
-};
-
-// src/sdk/types.ts
-import { Schema as Schema2 } from "effect";
-var OperationId = Schema2.String.pipe(Schema2.brand("OperationId"));
-var HttpMethod = Schema2.Literal(
-  "get",
-  "put",
-  "post",
-  "delete",
-  "patch",
-  "head",
-  "options",
-  "trace"
-);
-var ParameterLocation = Schema2.Literal("path", "query", "header", "cookie");
-var OperationParameter = class extends Schema2.Class("OperationParameter")({
-  name: Schema2.String,
-  location: ParameterLocation,
-  required: Schema2.Boolean,
-  schema: Schema2.optionalWith(Schema2.Unknown, { as: "Option" }),
-  style: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  explode: Schema2.optionalWith(Schema2.Boolean, { as: "Option" }),
-  allowReserved: Schema2.optionalWith(Schema2.Boolean, { as: "Option" }),
-  description: Schema2.optionalWith(Schema2.String, { as: "Option" })
-}) {
-};
-var OperationRequestBody = class extends Schema2.Class(
-  "OperationRequestBody"
-)({
-  required: Schema2.Boolean,
-  contentType: Schema2.String,
-  schema: Schema2.optionalWith(Schema2.Unknown, { as: "Option" })
-}) {
-};
-var ExtractedOperation = class extends Schema2.Class("ExtractedOperation")({
-  operationId: OperationId,
-  method: HttpMethod,
-  pathTemplate: Schema2.String,
-  summary: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  description: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  tags: Schema2.Array(Schema2.String),
-  parameters: Schema2.Array(OperationParameter),
-  requestBody: Schema2.optionalWith(OperationRequestBody, { as: "Option" }),
-  inputSchema: Schema2.optionalWith(Schema2.Unknown, { as: "Option" }),
-  outputSchema: Schema2.optionalWith(Schema2.Unknown, { as: "Option" }),
-  deprecated: Schema2.optionalWith(Schema2.Boolean, { default: () => false })
-}) {
-};
-var ServerInfo = class extends Schema2.Class("ServerInfo")({
-  url: Schema2.String,
-  variables: Schema2.optionalWith(Schema2.Record({ key: Schema2.String, value: Schema2.String }), {
-    as: "Option"
-  })
-}) {
-};
-var ExtractionResult = class extends Schema2.Class("ExtractionResult")({
-  title: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  version: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  servers: Schema2.Array(ServerInfo),
-  operations: Schema2.Array(ExtractedOperation)
-}) {
-};
-var OperationBinding = class extends Schema2.Class("OperationBinding")({
-  method: HttpMethod,
-  pathTemplate: Schema2.String,
-  parameters: Schema2.Array(OperationParameter),
-  requestBody: Schema2.optionalWith(OperationRequestBody, { as: "Option" })
-}) {
-};
-var HeaderValue = Schema2.Union(
-  Schema2.String,
-  Schema2.Struct({
-    secretId: Schema2.String,
-    prefix: Schema2.optional(Schema2.String)
-  })
-);
-var InvocationConfig = class extends Schema2.Class("InvocationConfig")({
-  baseUrl: Schema2.String,
-  /** Headers applied to every request. Values can reference secrets. */
-  headers: Schema2.optionalWith(Schema2.Record({ key: Schema2.String, value: HeaderValue }), {
-    default: () => ({})
-  })
-}) {
-};
-var InvocationResult = class extends Schema2.Class("InvocationResult")({
-  status: Schema2.Number,
-  headers: Schema2.Record({ key: Schema2.String, value: Schema2.String }),
-  data: Schema2.NullOr(Schema2.Unknown),
-  error: Schema2.NullOr(Schema2.Unknown)
-}) {
-};
-
-// src/sdk/extract.ts
-import { Effect as Effect2, Option as Option2 } from "effect";
-var HTTP_METHODS = [
-  "get",
-  "put",
-  "post",
-  "delete",
-  "patch",
-  "head",
-  "options",
-  "trace"
-];
-var VALID_PARAM_LOCATIONS = /* @__PURE__ */ new Set(["path", "query", "header", "cookie"]);
-var extractParameters = (pathItem, operation, r) => {
-  const merged = /* @__PURE__ */ new Map();
-  for (const raw of pathItem.parameters ?? []) {
-    const p = r.resolve(raw);
-    if (!p) continue;
-    merged.set(`${p.in}:${p.name}`, p);
-  }
-  for (const raw of operation.parameters ?? []) {
-    const p = r.resolve(raw);
-    if (!p) continue;
-    merged.set(`${p.in}:${p.name}`, p);
-  }
-  return [...merged.values()].filter((p) => VALID_PARAM_LOCATIONS.has(p.in)).map(
-    (p) => new OperationParameter({
-      name: p.name,
-      location: p.in,
-      required: p.in === "path" ? true : p.required === true,
-      schema: Option2.fromNullable(p.schema),
-      style: Option2.fromNullable(p.style),
-      explode: Option2.fromNullable(p.explode),
-      allowReserved: Option2.fromNullable("allowReserved" in p ? p.allowReserved : void 0),
-      description: Option2.fromNullable(p.description)
-    })
-  );
-};
-var extractRequestBody = (operation, r) => {
-  if (!operation.requestBody) return void 0;
-  const body = r.resolve(operation.requestBody);
-  if (!body) return void 0;
-  const content = preferredContent(body.content);
-  if (!content) return void 0;
-  return new OperationRequestBody({
-    required: body.required === true,
-    contentType: content.mediaType,
-    schema: Option2.fromNullable(content.media.schema)
-  });
-};
-var extractOutputSchema = (operation, r) => {
-  if (!operation.responses) return void 0;
-  const entries = Object.entries(operation.responses);
-  const preferred = [
-    ...entries.filter(([s]) => /^2\d\d$/.test(s)).sort(([a], [b]) => a.localeCompare(b)),
-    ...entries.filter(([s]) => s === "default")
-  ];
-  for (const [, ref] of preferred) {
-    const resp = r.resolve(ref);
-    if (!resp) continue;
-    const content = preferredContent(resp.content);
-    if (content?.media.schema) return content.media.schema;
-  }
-  return void 0;
-};
-var buildInputSchema = (parameters, requestBody) => {
-  const properties = {};
-  const required = [];
-  for (const param of parameters) {
-    properties[param.name] = Option2.getOrElse(param.schema, () => ({ type: "string" }));
-    if (param.required) required.push(param.name);
-  }
-  if (requestBody) {
-    properties.body = Option2.getOrElse(requestBody.schema, () => ({ type: "object" }));
-    if (requestBody.required) required.push("body");
-  }
-  if (Object.keys(properties).length === 0) return void 0;
-  return {
-    type: "object",
-    properties,
-    ...required.length > 0 ? { required } : {},
-    additionalProperties: false
-  };
-};
-var deriveOperationId = (method, pathTemplate, operation) => operation.operationId ?? (`${method}_${pathTemplate.replace(/[^a-zA-Z0-9]+/g, "_")}`.replace(/^_+|_+$/g, "") || `${method}_operation`);
-var extractServers = (doc) => (doc.servers ?? []).flatMap((server) => {
-  if (!server.url) return [];
-  const vars = server.variables ? Object.fromEntries(
-    Object.entries(server.variables).flatMap(
-      ([name, v]) => v.default ? [[name, v.default]] : []
-    )
-  ) : void 0;
-  return [
-    new ServerInfo({
-      url: server.url,
-      variables: vars && Object.keys(vars).length > 0 ? Option2.some(vars) : Option2.none()
-    })
-  ];
-});
-var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
-  const paths = doc.paths;
-  if (!paths) {
-    return yield* new OpenApiExtractionError({
-      message: "OpenAPI document has no paths defined"
-    });
-  }
-  const r = new DocResolver(doc);
-  const operations = [];
-  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 parameters = extractParameters(pathItem, operation, r);
-      const requestBody = extractRequestBody(operation, r);
-      const inputSchema = buildInputSchema(parameters, requestBody);
-      const outputSchema = extractOutputSchema(operation, r);
-      const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);
-      operations.push(
-        new ExtractedOperation({
-          operationId: OperationId.make(deriveOperationId(method, pathTemplate, operation)),
-          method,
-          pathTemplate,
-          summary: Option2.fromNullable(operation.summary),
-          description: Option2.fromNullable(operation.description),
-          tags,
-          parameters,
-          requestBody: Option2.fromNullable(requestBody),
-          inputSchema: Option2.fromNullable(inputSchema),
-          outputSchema: Option2.fromNullable(outputSchema),
-          deprecated: operation.deprecated === true
-        })
-      );
-    }
-  }
-  return new ExtractionResult({
-    title: Option2.fromNullable(doc.info?.title),
-    version: Option2.fromNullable(doc.info?.version),
-    servers: extractServers(doc),
-    operations
-  });
-});
-
-// src/sdk/invoke.ts
-import { Effect as Effect3, Layer, Option as Option3 } from "effect";
-import { HttpClient, HttpClientRequest } from "@effect/platform";
-import {
-  ToolInvocationResult,
-  ToolInvocationError
-} from "@executor-js/sdk";
-var CONTAINER_KEYS = {
-  path: ["path", "pathParams", "params"],
-  query: ["query", "queryParams", "params"],
-  header: ["headers", "header"],
-  cookie: ["cookies", "cookie"]
-};
-var readParamValue = (args, param) => {
-  const direct = args[param.name];
-  if (direct !== void 0) return direct;
-  for (const key of CONTAINER_KEYS[param.location] ?? []) {
-    const container = args[key];
-    if (typeof container === "object" && container !== null && !Array.isArray(container)) {
-      const nested = container[param.name];
-      if (nested !== void 0) return nested;
-    }
-  }
-  return void 0;
-};
-var resolvePath = Effect3.fn("OpenApi.resolvePath")(function* (pathTemplate, args, parameters) {
-  let resolved = pathTemplate;
-  for (const param of parameters) {
-    if (param.location !== "path") continue;
-    const value = readParamValue(args, param);
-    if (value === void 0 || value === null) {
-      if (param.required) {
-        return yield* new OpenApiInvocationError({
-          message: `Missing required path parameter: ${param.name}`,
-          statusCode: Option3.none()
-        });
-      }
-      continue;
-    }
-    resolved = resolved.replaceAll(`{${param.name}}`, encodeURIComponent(String(value)));
-  }
-  const remaining = [...resolved.matchAll(/\{([^{}]+)\}/g)].map((m) => m[1]).filter((v) => typeof v === "string");
-  for (const name of remaining) {
-    const value = args[name];
-    if (value !== void 0 && value !== null) {
-      resolved = resolved.replaceAll(`{${name}}`, encodeURIComponent(String(value)));
-    }
-  }
-  const unresolved = [...resolved.matchAll(/\{([^{}]+)\}/g)].map((m) => m[1]).filter((v) => typeof v === "string");
-  if (unresolved.length > 0) {
-    return yield* new OpenApiInvocationError({
-      message: `Unresolved path parameters: ${[...new Set(unresolved)].join(", ")}`,
-      statusCode: Option3.none()
-    });
-  }
-  return resolved;
-});
-var resolveHeaders = (headers, secrets, scopeId) => Effect3.gen(function* () {
-  const resolved = {};
-  for (const [name, value] of Object.entries(headers)) {
-    if (typeof value === "string") {
-      resolved[name] = value;
-    } else {
-      const secret = yield* secrets.resolve(value.secretId, scopeId).pipe(
-        Effect3.mapError(
-          () => new ToolInvocationError({
-            toolId: "",
-            message: `Failed to resolve secret "${value.secretId}" for header "${name}"`,
-            cause: void 0
-          })
-        )
-      );
-      resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
-    }
-  }
-  return resolved;
-});
-var applyHeaders = (request, headers) => {
-  let req = request;
-  for (const [name, value] of Object.entries(headers)) {
-    req = HttpClientRequest.setHeader(req, name, value);
-  }
-  return req;
-};
-var isJsonContentType = (ct) => {
-  if (!ct) return false;
-  const normalized = ct.split(";")[0]?.trim().toLowerCase() ?? "";
-  return normalized === "application/json" || normalized.includes("+json") || normalized.includes("json");
-};
-var invoke = Effect3.fn("OpenApi.invoke")(function* (operation, args, config, resolvedHeaders) {
-  const client = yield* HttpClient.HttpClient;
-  const resolvedPath = yield* resolvePath(operation.pathTemplate, args, operation.parameters);
-  const path = resolvedPath.startsWith("/") ? resolvedPath : `/${resolvedPath}`;
-  let request = HttpClientRequest.make(operation.method.toUpperCase())(path);
-  for (const param of operation.parameters) {
-    if (param.location !== "query") continue;
-    const value = readParamValue(args, param);
-    if (value === void 0 || value === null) continue;
-    request = HttpClientRequest.setUrlParam(request, param.name, String(value));
-  }
-  for (const param of operation.parameters) {
-    if (param.location !== "header") continue;
-    const value = readParamValue(args, param);
-    if (value === void 0 || value === null) continue;
-    request = HttpClientRequest.setHeader(request, param.name, String(value));
-  }
-  if (Option3.isSome(operation.requestBody)) {
-    const rb = operation.requestBody.value;
-    const bodyValue = args.body ?? args.input;
-    if (bodyValue !== void 0) {
-      if (isJsonContentType(rb.contentType)) {
-        request = HttpClientRequest.bodyUnsafeJson(request, bodyValue);
-      } else {
-        request = HttpClientRequest.bodyText(request, String(bodyValue), rb.contentType);
-      }
-    }
-  }
-  request = applyHeaders(request, resolvedHeaders ?? {});
-  const response = yield* client.execute(request).pipe(
-    Effect3.mapError(
-      (err) => new OpenApiInvocationError({
-        message: `HTTP request failed: ${err.message}`,
-        statusCode: Option3.none(),
-        cause: err
-      })
-    )
-  );
-  const status = response.status;
-  const responseHeaders = { ...response.headers };
-  const contentType = response.headers["content-type"] ?? null;
-  const responseBody = status === 204 ? null : isJsonContentType(contentType) ? yield* response.json.pipe(Effect3.catchAll(() => response.text)) : yield* response.text;
-  const ok = status >= 200 && status < 300;
-  return new InvocationResult({
-    status,
-    headers: responseHeaders,
-    data: ok ? responseBody : null,
-    error: ok ? null : responseBody
-  });
-});
-var SAFE_METHODS = /* @__PURE__ */ new Set(["get", "head", "options"]);
-var annotationsForOperation = (method, pathTemplate) => {
-  if (SAFE_METHODS.has(method.toLowerCase())) return {};
-  return {
-    requiresApproval: true,
-    approvalDescription: `${method.toUpperCase()} ${pathTemplate}`
-  };
-};
-var makeOpenApiInvoker = (opts) => ({
-  resolveAnnotations: (toolId) => Effect3.gen(function* () {
-    const entry = yield* opts.operationStore.get(toolId);
-    if (!entry) return void 0;
-    return annotationsForOperation(entry.binding.method, entry.binding.pathTemplate);
-  }),
-  invoke: (toolId, args) => Effect3.gen(function* () {
-    const entry = yield* opts.operationStore.get(toolId);
-    if (!entry) {
-      return yield* new ToolInvocationError({
-        toolId,
-        message: `No operation found for tool "${toolId}"`,
-        cause: void 0
-      });
-    }
-    const source = yield* opts.operationStore.getSource(entry.namespace);
-    if (!source) {
-      return yield* new ToolInvocationError({
-        toolId,
-        message: `No source found for namespace "${entry.namespace}"`,
-        cause: void 0
-      });
-    }
-    const { binding } = entry;
-    const { invocationConfig: config } = source;
-    const baseUrl = config.baseUrl;
-    const resolvedHeaders = yield* resolveHeaders(config.headers, opts.secrets, opts.scopeId);
-    const clientWithBaseUrl = baseUrl ? Layer.effect(
-      HttpClient.HttpClient,
-      Effect3.map(
-        HttpClient.HttpClient,
-        HttpClient.mapRequest(HttpClientRequest.prependUrl(baseUrl))
-      )
-    ).pipe(Layer.provide(opts.httpClientLayer)) : opts.httpClientLayer;
-    const result = yield* invoke(
-      binding,
-      args ?? {},
-      config,
-      resolvedHeaders
-    ).pipe(Effect3.provide(clientWithBaseUrl));
-    return new ToolInvocationResult({
-      data: result.data,
-      error: result.error,
-      status: result.status
-    });
-  }).pipe(
-    Effect3.catchAll((err) => {
-      if (typeof err === "object" && err !== null && "_tag" in err && err._tag === "ToolInvocationError") {
-        return Effect3.fail(err);
-      }
-      return Effect3.fail(
-        new ToolInvocationError({
-          toolId,
-          message: `OpenAPI invocation failed: ${err instanceof Error ? err.message : String(err)}`,
-          cause: err
-        })
-      );
-    })
-  )
-});
-
-// src/sdk/kv-operation-store.ts
-import { Effect as Effect4, Schema as Schema4 } from "effect";
-import { scopeKv, makeInMemoryScopedKv } from "@executor-js/sdk";
-
-// src/sdk/stored-source.ts
-import { Schema as Schema3 } from "effect";
-var StoredSourceSchema = class extends Schema3.Class("OpenApiStoredSource")({
-  namespace: Schema3.String,
-  name: Schema3.String,
-  config: Schema3.Struct({
-    spec: Schema3.String,
-    baseUrl: Schema3.optional(Schema3.String),
-    namespace: Schema3.optional(Schema3.String),
-    headers: Schema3.optional(Schema3.Record({ key: Schema3.String, value: HeaderValue }))
-  }),
-  // TODO(migration): make required once all rows have been migrated to
-  // carry invocationConfig. Left optional for decode compat with rows
-  // written before the source-level invocationConfig refactor.
-  invocationConfig: Schema3.optional(InvocationConfig)
-}) {
-};
-
-// src/sdk/kv-operation-store.ts
-var StoredEntry = class extends Schema4.Class("StoredEntry")({
-  namespace: Schema4.String,
-  binding: OperationBinding
-}) {
-};
-var encodeEntry = Schema4.encodeSync(Schema4.parseJson(StoredEntry));
-var decodeEntry = Schema4.decodeUnknownSync(Schema4.parseJson(StoredEntry));
-var LegacyStoredEntry = class extends Schema4.Class("LegacyStoredEntry")({
-  namespace: Schema4.String,
-  binding: OperationBinding,
-  config: Schema4.optional(InvocationConfig)
-}) {
-};
-var decodeLegacyEntry = Schema4.decodeUnknownSync(Schema4.parseJson(LegacyStoredEntry));
-var encodeSource = Schema4.encodeSync(Schema4.parseJson(StoredSourceSchema));
-var decodeSource = Schema4.decodeUnknownSync(Schema4.parseJson(StoredSourceSchema));
-var makeStore = (bindings, sources) => {
-  const withKvTransaction = (kv, effect) => kv.withTransaction?.(effect) ?? effect;
-  const rehydrateInvocationConfig = (source) => Effect4.gen(function* () {
-    if (source.invocationConfig) return source;
-    let recovered = null;
-    const entries = yield* bindings.list();
-    for (const e of entries) {
-      const legacy = decodeLegacyEntry(e.value);
-      if (legacy.namespace === source.namespace && legacy.config) {
-        recovered = legacy.config;
-        break;
-      }
-    }
-    const invocationConfig = recovered ?? new InvocationConfig({
-      baseUrl: source.config.baseUrl ?? "",
-      headers: source.config.headers ?? {}
-    });
-    return { ...source, invocationConfig };
-  });
-  return {
-    get: (toolId) => Effect4.gen(function* () {
-      const raw = yield* bindings.get(toolId);
-      if (!raw) return null;
-      const entry = decodeEntry(raw);
-      return { binding: entry.binding, namespace: entry.namespace };
-    }),
-    put: (entries) => withKvTransaction(
-      bindings,
-      bindings.set(
-        entries.map(({ toolId, namespace, binding }) => ({
-          key: toolId,
-          value: encodeEntry(new StoredEntry({ namespace, binding }))
-        }))
-      )
-    ),
-    remove: (toolId) => bindings.delete([toolId]).pipe(Effect4.asVoid),
-    listByNamespace: (namespace) => Effect4.gen(function* () {
-      const entries = yield* bindings.list();
-      const ids = [];
-      for (const e of entries) {
-        const entry = decodeEntry(e.value);
-        if (entry.namespace === namespace) ids.push(e.key);
-      }
-      return ids;
-    }),
-    removeByNamespace: (namespace) => Effect4.gen(function* () {
-      const entries = yield* bindings.list();
-      const ids = [];
-      for (const e of entries) {
-        const entry = decodeEntry(e.value);
-        if (entry.namespace === namespace) ids.push(e.key);
-      }
-      if (ids.length > 0) yield* bindings.delete(ids);
-      return ids;
-    }),
-    putSource: (source) => sources.set([{ key: source.namespace, value: encodeSource(source) }]),
-    removeSource: (namespace) => sources.delete([namespace]).pipe(Effect4.asVoid),
-    listSources: () => Effect4.gen(function* () {
-      const entries = yield* sources.list();
-      const out = [];
-      for (const e of entries) {
-        const raw = decodeSource(e.value);
-        out.push(
-          raw.invocationConfig ? raw : yield* rehydrateInvocationConfig(raw)
-        );
-      }
-      return out;
-    }),
-    getSource: (namespace) => Effect4.gen(function* () {
-      const raw = yield* sources.get(namespace);
-      if (!raw) return null;
-      const source = decodeSource(raw);
-      if (source.invocationConfig) return source;
-      const healed = yield* rehydrateInvocationConfig(source);
-      yield* sources.set([{ key: namespace, value: encodeSource(healed) }]);
-      return healed;
-    }),
-    getSourceConfig: (namespace) => Effect4.gen(function* () {
-      const raw = yield* sources.get(namespace);
-      if (!raw) return null;
-      const source = decodeSource(raw);
-      return source.config;
-    })
-  };
-};
-var makeKvOperationStore = (kv, namespace) => makeStore(scopeKv(kv, `${namespace}.bindings`), scopeKv(kv, `${namespace}.sources`));
-var makeInMemoryOperationStore = () => makeStore(makeInMemoryScopedKv(), makeInMemoryScopedKv());
-
-// src/sdk/preview.ts
-import { Effect as Effect5, Option as Option4 } from "effect";
-import { Schema as Schema5 } from "effect";
-var SecurityScheme = class extends Schema5.Class("SecurityScheme")({
-  /** Key name in components.securitySchemes (e.g. "api_token") */
-  name: Schema5.String,
-  /** OpenAPI security scheme type */
-  type: Schema5.Literal("http", "apiKey", "oauth2", "openIdConnect"),
-  /** For type: "http" — e.g. "bearer", "basic" */
-  scheme: Schema5.optionalWith(Schema5.String, { as: "Option" }),
-  /** For type: "apiKey" — where the key goes */
-  in: Schema5.optionalWith(Schema5.Literal("header", "query", "cookie"), { as: "Option" }),
-  /** For type: "apiKey" — the header/query/cookie name */
-  headerName: Schema5.optionalWith(Schema5.String, { as: "Option" }),
-  description: Schema5.optionalWith(Schema5.String, { as: "Option" })
-}) {
-};
-var AuthStrategy = class extends Schema5.Class("AuthStrategy")({
-  /** The security schemes required together for this strategy */
-  schemes: Schema5.Array(Schema5.String)
-}) {
-};
-var HeaderPreset = class extends Schema5.Class("HeaderPreset")({
-  /** Human-readable label for the UI (e.g. "Bearer Token", "API Key + Email") */
-  label: Schema5.String,
-  /** Headers this strategy needs. Value is null when the user must provide it. */
-  headers: Schema5.Record({ key: Schema5.String, value: Schema5.NullOr(Schema5.String) }),
-  /** Which headers should be stored as secrets */
-  secretHeaders: Schema5.Array(Schema5.String)
-}) {
-};
-var PreviewOperation = class extends Schema5.Class("PreviewOperation")({
-  operationId: Schema5.String,
-  method: HttpMethod,
-  path: Schema5.String,
-  summary: Schema5.optionalWith(Schema5.String, { as: "Option" }),
-  tags: Schema5.Array(Schema5.String),
-  deprecated: Schema5.Boolean
-}) {
-};
-var SpecPreview = class extends Schema5.Class("SpecPreview")({
-  title: Schema5.optionalWith(Schema5.String, { as: "Option" }),
-  version: Schema5.optionalWith(Schema5.String, { as: "Option" }),
-  /** Reuses ServerInfo from extraction */
-  servers: Schema5.Array(Schema5.Unknown),
-  operationCount: Schema5.Number,
-  /** Lightweight operation list for the add-source UI */
-  operations: Schema5.Array(PreviewOperation),
-  tags: Schema5.Array(Schema5.String),
-  securitySchemes: Schema5.Array(SecurityScheme),
-  /** Valid auth strategies (each is a set of schemes used together) */
-  authStrategies: Schema5.Array(AuthStrategy),
-  /** Pre-built header presets derived from auth strategies */
-  headerPresets: Schema5.Array(HeaderPreset)
-}) {
-};
-var extractSecuritySchemes = (rawSchemes) => Object.entries(rawSchemes).flatMap(([name, schemeOrRef]) => {
-  if (!schemeOrRef || typeof schemeOrRef !== "object") return [];
-  const scheme = schemeOrRef;
-  if ("$ref" in scheme) return [];
-  const type = scheme.type;
-  if (!["http", "apiKey", "oauth2", "openIdConnect"].includes(type)) return [];
-  return [
-    new SecurityScheme({
-      name,
-      type,
-      scheme: Option4.fromNullable(scheme.scheme),
-      in: Option4.fromNullable(scheme.in),
-      headerName: Option4.fromNullable(scheme.name),
-      description: Option4.fromNullable(scheme.description)
-    })
-  ];
-});
-var buildHeaderPresets = (schemes, strategies) => {
-  const schemeMap = new Map(schemes.map((s) => [s.name, s]));
-  return strategies.flatMap((strategy) => {
-    const resolved = strategy.schemes.map((name) => schemeMap.get(name)).filter((s) => s !== void 0);
-    if (resolved.length === 0) return [];
-    const headers = {};
-    const secretHeaders = [];
-    const labelParts = [];
-    for (const scheme of resolved) {
-      if (scheme.type === "http" && Option4.getOrElse(scheme.scheme, () => "") === "bearer") {
-        headers["Authorization"] = null;
-        secretHeaders.push("Authorization");
-        labelParts.push("Bearer Token");
-      } else if (scheme.type === "http" && Option4.getOrElse(scheme.scheme, () => "") === "basic") {
-        headers["Authorization"] = null;
-        secretHeaders.push("Authorization");
-        labelParts.push("Basic Auth");
-      } else if (scheme.type === "apiKey" && Option4.getOrElse(scheme.in, () => "") === "header") {
-        const headerName = Option4.getOrElse(scheme.headerName, () => scheme.name);
-        headers[headerName] = null;
-        secretHeaders.push(headerName);
-        labelParts.push(scheme.name);
-      } else if (scheme.type === "apiKey") {
-        labelParts.push(`${scheme.name} (${Option4.getOrElse(scheme.in, () => "unknown")})`);
-      } else {
-        labelParts.push(scheme.name);
-      }
-    }
-    if (Object.keys(headers).length === 0 && resolved.length > 0) {
-      return [new HeaderPreset({ label: labelParts.join(" + "), headers: {}, secretHeaders: [] })];
-    }
-    return [new HeaderPreset({ label: labelParts.join(" + "), headers, secretHeaders })];
-  });
-};
-var collectTags = (result) => {
-  const tagSet = /* @__PURE__ */ new Set();
-  for (const op of result.operations) {
-    for (const tag of op.tags) tagSet.add(tag);
-  }
-  return [...tagSet].sort();
-};
-var previewSpec = Effect5.fn("OpenApi.previewSpec")(function* (specText) {
-  const doc = yield* parse(specText);
-  const result = yield* extract(doc);
-  const securitySchemes = extractSecuritySchemes(doc.components?.securitySchemes ?? {});
-  const rawSecurity = doc.security ?? [];
-  const authStrategies = rawSecurity.map(
-    (entry) => new AuthStrategy({ schemes: Object.keys(entry) })
-  );
-  return new SpecPreview({
-    title: result.title,
-    version: result.version,
-    servers: result.servers,
-    operationCount: result.operations.length,
-    operations: result.operations.map(
-      (op) => new PreviewOperation({
-        operationId: op.operationId,
-        method: op.method,
-        path: op.pathTemplate,
-        summary: op.summary,
-        tags: op.tags,
-        deprecated: op.deprecated
-      })
-    ),
-    tags: collectTags(result),
-    securitySchemes,
-    authStrategies,
-    headerPresets: buildHeaderPresets(securitySchemes, authStrategies)
-  });
-});
-
-// src/sdk/plugin.ts
-import { Effect as Effect6, Option as Option5, Schema as Schema6 } from "effect";
-import { FetchHttpClient } from "@effect/platform";
-import {
-  Source,
-  SourceDetectionResult,
-  definePlugin,
-  registerRuntimeTools,
-  runtimeTool,
-  ToolId
-} from "@executor-js/sdk";
-
-// src/sdk/definitions.ts
-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 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/plugin.ts
-var PreviewSpecInputSchema = Schema6.Struct({
-  spec: Schema6.String
-});
-var AddSourceInputSchema = Schema6.Struct({
-  spec: Schema6.String,
-  baseUrl: Schema6.optional(Schema6.String),
-  namespace: Schema6.optional(Schema6.String),
-  headers: Schema6.optional(Schema6.Record({ key: Schema6.String, value: HeaderValue }))
-});
-var AddSourceOutputSchema = Schema6.Struct({
-  sourceId: Schema6.String,
-  toolCount: Schema6.Number
-});
-var normalizeOpenApiRefs = (node) => {
-  if (node == null || typeof node !== "object") return node;
-  if (Array.isArray(node)) {
-    let changed2 = false;
-    const out = node.map((item) => {
-      const n = normalizeOpenApiRefs(item);
-      if (n !== item) changed2 = true;
-      return n;
-    });
-    return changed2 ? out : node;
-  }
-  const obj = node;
-  if (typeof obj.$ref === "string") {
-    const match = obj.$ref.match(/^#\/components\/schemas\/(.+)$/);
-    if (match) return { ...obj, $ref: `#/$defs/${match[1]}` };
-    return obj;
-  }
-  let changed = false;
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    const n = normalizeOpenApiRefs(v);
-    if (n !== v) changed = true;
-    result[k] = n;
-  }
-  return changed ? result : obj;
-};
-var toRegistration = (def, namespace) => {
-  const op = def.operation;
-  const description = Option5.getOrElse(
-    op.description,
-    () => Option5.getOrElse(op.summary, () => `${op.method.toUpperCase()} ${op.pathTemplate}`)
-  );
-  return {
-    id: ToolId.make(`${namespace}.${def.toolPath}`),
-    pluginKey: "openapi",
-    sourceId: namespace,
-    name: def.toolPath,
-    description,
-    inputSchema: normalizeOpenApiRefs(Option5.getOrUndefined(op.inputSchema)),
-    outputSchema: normalizeOpenApiRefs(Option5.getOrUndefined(op.outputSchema))
-  };
-};
-var toBinding = (def) => new OperationBinding({
-  method: def.operation.method,
-  pathTemplate: def.operation.pathTemplate,
-  parameters: [...def.operation.parameters],
-  requestBody: def.operation.requestBody
-});
-var openApiPlugin = (options) => {
-  const httpClientLayer = options?.httpClientLayer ?? FetchHttpClient.layer;
-  const operationStore = options?.operationStore ?? makeInMemoryOperationStore();
-  return definePlugin({
-    key: "openapi",
-    init: (ctx) => Effect6.gen(function* () {
-      yield* ctx.tools.registerInvoker(
-        "openapi",
-        makeOpenApiInvoker({
-          operationStore,
-          httpClientLayer,
-          secrets: ctx.secrets,
-          scopeId: ctx.scope.id
-        })
-      );
-      yield* ctx.sources.addManager({
-        kind: "openapi",
-        list: () => operationStore.listSources().pipe(
-          Effect6.map(
-            (metas) => metas.map(
-              (s) => new Source({
-                id: s.namespace,
-                name: s.name,
-                kind: "openapi",
-                url: s.config.baseUrl,
-                runtime: false,
-                canRemove: true,
-                canRefresh: false,
-                canEdit: true
-              })
-            )
-          )
-        ),
-        remove: (sourceId) => Effect6.gen(function* () {
-          yield* operationStore.removeByNamespace(sourceId);
-          yield* operationStore.removeSource(sourceId);
-          yield* ctx.tools.unregisterBySource(sourceId);
-        }),
-        detect: (url) => Effect6.gen(function* () {
-          const trimmed = url.trim();
-          if (!trimmed) return null;
-          const parsed = yield* Effect6.try(() => new URL(trimmed)).pipe(Effect6.option);
-          if (parsed._tag === "None") return null;
-          const doc = yield* parse(trimmed).pipe(Effect6.catchAll(() => Effect6.succeed(null)));
-          if (!doc) return null;
-          const result = yield* extract(doc).pipe(Effect6.catchAll(() => Effect6.succeed(null)));
-          if (!result) return null;
-          const namespace = Option5.getOrElse(result.title, () => "api").toLowerCase().replace(/[^a-z0-9]+/g, "_");
-          const name = Option5.getOrElse(result.title, () => namespace);
-          return new SourceDetectionResult({
-            kind: "openapi",
-            confidence: "high",
-            endpoint: trimmed,
-            name,
-            namespace
-          });
-        })
-      });
-      const addSpecInternal = (config) => Effect6.gen(function* () {
-        const doc = yield* parse(config.spec);
-        const result = yield* extract(doc);
-        const namespace = config.namespace ?? Option5.getOrElse(result.title, () => "api").toLowerCase().replace(/[^a-z0-9]+/g, "_");
-        if (doc.components?.schemas) {
-          const defs = {};
-          for (const [k, v] of Object.entries(doc.components.schemas)) {
-            defs[k] = normalizeOpenApiRefs(v);
-          }
-          yield* ctx.tools.registerDefinitions(defs);
-        }
-        const baseUrl = config.baseUrl ?? resolveBaseUrl(result.servers);
-        const invocationConfig = new InvocationConfig({
-          baseUrl,
-          headers: config.headers ?? {}
-        });
-        const definitions = compileToolDefinitions(result.operations);
-        const registrations = definitions.map((def) => toRegistration(def, namespace));
-        yield* operationStore.put(
-          definitions.map((def) => ({
-            toolId: ToolId.make(`${namespace}.${def.toolPath}`),
-            namespace,
-            binding: toBinding(def)
-          }))
-        );
-        yield* ctx.tools.register(registrations);
-        const sourceName = config.name ?? Option5.getOrElse(result.title, () => namespace);
-        yield* operationStore.putSource({
-          namespace,
-          name: sourceName,
-          config: {
-            spec: config.spec,
-            baseUrl: config.baseUrl,
-            namespace: config.namespace,
-            headers: config.headers
-          },
-          invocationConfig
-        });
-        return { sourceId: namespace, toolCount: registrations.length };
-      });
-      const runtimeTools = yield* registerRuntimeTools({
-        registry: ctx.tools,
-        sources: ctx.sources,
-        pluginKey: "openapi",
-        source: {
-          id: "built-in",
-          name: "Built In",
-          kind: "built-in"
-        },
-        tools: [
-          runtimeTool({
-            id: "openapi.previewSpec",
-            name: "openapi.previewSpec",
-            description: "Preview an OpenAPI document before adding it as a source",
-            inputSchema: PreviewSpecInputSchema,
-            outputSchema: SpecPreview,
-            handler: ({ spec }) => previewSpec(spec)
-          }),
-          runtimeTool({
-            id: "openapi.addSource",
-            name: "openapi.addSource",
-            description: "Add an OpenAPI source and register its operations as tools",
-            inputSchema: AddSourceInputSchema,
-            outputSchema: AddSourceOutputSchema,
-            handler: (input) => addSpecInternal(input)
-          })
-        ]
-      });
-      return {
-        extension: {
-          previewSpec: (specText) => previewSpec(specText),
-          addSpec: (config) => addSpecInternal(config).pipe(Effect6.map(({ toolCount }) => ({ toolCount }))),
-          removeSpec: (namespace) => Effect6.gen(function* () {
-            const toolIds = yield* operationStore.removeByNamespace(namespace);
-            if (toolIds.length > 0) {
-              yield* ctx.tools.unregister(toolIds);
-            }
-            yield* operationStore.removeSource(namespace);
-          }),
-          getSource: (namespace) => operationStore.getSource(namespace),
-          updateSource: (namespace, input) => Effect6.gen(function* () {
-            const existing = yield* operationStore.getSource(namespace);
-            if (!existing) return;
-            const updatedConfig = {
-              ...existing.config,
-              ...input.baseUrl !== void 0 ? { baseUrl: input.baseUrl } : {},
-              ...input.headers !== void 0 ? { headers: input.headers } : {}
-            };
-            const newInvocationConfig = new InvocationConfig({
-              baseUrl: updatedConfig.baseUrl ?? existing.invocationConfig.baseUrl,
-              headers: updatedConfig.headers ?? {}
-            });
-            yield* operationStore.putSource({
-              namespace,
-              name: input.name?.trim() || existing.name,
-              config: updatedConfig,
-              invocationConfig: newInvocationConfig
-            });
-          })
-        },
-        close: () => runtimeTools.close()
-      };
-    })
-  });
-};
-
-export {
-  OpenApiParseError,
-  OpenApiExtractionError,
-  OpenApiInvocationError,
-  parse,
-  DocResolver,
-  resolveBaseUrl,
-  preferredContent,
-  OperationId,
-  HttpMethod,
-  ParameterLocation,
-  OperationParameter,
-  OperationRequestBody,
-  ExtractedOperation,
-  ServerInfo,
-  ExtractionResult,
-  OperationBinding,
-  InvocationConfig,
-  InvocationResult,
-  extract,
-  invoke,
-  makeOpenApiInvoker,
-  makeKvOperationStore,
-  makeInMemoryOperationStore,
-  SecurityScheme,
-  AuthStrategy,
-  HeaderPreset,
-  PreviewOperation,
-  SpecPreview,
-  previewSpec,
-  openApiPlugin
-};
-//# sourceMappingURL=chunk-KPGROAQO.js.map