@executor-js/plugin-openapi 0.0.1-beta.4 → 0.0.1-beta.6

package/dist/{chunk-C57CSNPZ.js → chunk-V3D5A6HA.js}

@@ -14,9 +14,7 @@ var OpenApiExtractionError = class extends Schema.TaggedError()(
   }
 ) {
 };
-var OpenApiInvocationError = class extends Data.TaggedError(
-  "OpenApiInvocationError"
-) {
+var OpenApiInvocationError = class extends Data.TaggedError("OpenApiInvocationError") {
 };
 
 // src/sdk/parse.ts
@@ -25,11 +23,15 @@ import { Effect } from "effect";
 import YAML from "yaml";
 var parse = Effect.fn("OpenApi.parse")(function* (input) {
   const api = yield* Effect.tryPromise({
-    try: () => {
-      if (input.startsWith("http://") || input.startsWith("https://")) {
-        return SwaggerParser.bundle(input);
+    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;
       }
-      return SwaggerParser.bundle(parseTextToObject(input));
     },
     catch: (error) => new OpenApiParseError({
       message: `Failed to parse OpenAPI document: ${error instanceof Error ? error.message : String(error)}`
@@ -59,6 +61,67 @@ var parseTextToObject = (text) => {
   }
   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";
@@ -69,7 +132,7 @@ var DocResolver = class {
   doc;
   /** Resolve a value that might be a $ref, returning the resolved object */
   resolve(value) {
-    if (isRef(value)) {
+    if (isRef2(value)) {
       const resolved = this.resolvePointer(value.$ref);
       return resolved;
     }
@@ -86,7 +149,7 @@ var DocResolver = class {
     return current;
   }
 };
-var isRef = (value) => typeof value === "object" && value !== null && "$ref" in value;
+var isRef2 = (value) => typeof value === "object" && value !== null && "$ref" in value;
 var resolveBaseUrl = (servers) => {
   const server = servers[0];
   if (!server) return "";
@@ -119,9 +182,7 @@ var HttpMethod = Schema2.Literal(
   "trace"
 );
 var ParameterLocation = Schema2.Literal("path", "query", "header", "cookie");
-var OperationParameter = class extends Schema2.Class(
-  "OperationParameter"
-)({
+var OperationParameter = class extends Schema2.Class("OperationParameter")({
   name: Schema2.String,
   location: ParameterLocation,
   required: Schema2.Boolean,
@@ -140,9 +201,7 @@ var OperationRequestBody = class extends Schema2.Class(
   schema: Schema2.optionalWith(Schema2.Unknown, { as: "Option" })
 }) {
 };
-var ExtractedOperation = class extends Schema2.Class(
-  "ExtractedOperation"
-)({
+var ExtractedOperation = class extends Schema2.Class("ExtractedOperation")({
   operationId: OperationId,
   method: HttpMethod,
   pathTemplate: Schema2.String,
@@ -158,24 +217,19 @@ var ExtractedOperation = class extends Schema2.Class(
 };
 var ServerInfo = class extends Schema2.Class("ServerInfo")({
   url: Schema2.String,
-  variables: Schema2.optionalWith(
-    Schema2.Record({ key: Schema2.String, value: Schema2.String }),
-    { as: "Option" }
-  )
+  variables: Schema2.optionalWith(Schema2.Record({ key: Schema2.String, value: Schema2.String }), {
+    as: "Option"
+  })
 }) {
 };
-var ExtractionResult = class extends Schema2.Class(
-  "ExtractionResult"
-)({
+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"
-)({
+var OperationBinding = class extends Schema2.Class("OperationBinding")({
   method: HttpMethod,
   pathTemplate: Schema2.String,
   parameters: Schema2.Array(OperationParameter),
@@ -189,20 +243,15 @@ var HeaderValue = Schema2.Union(
     prefix: Schema2.optional(Schema2.String)
   })
 );
-var InvocationConfig = class extends Schema2.Class(
-  "InvocationConfig"
-)({
+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: () => ({}) }
-  )
+  headers: Schema2.optionalWith(Schema2.Record({ key: Schema2.String, value: HeaderValue }), {
+    default: () => ({})
+  })
 }) {
 };
-var InvocationResult = class extends Schema2.Class(
-  "InvocationResult"
-)({
+var InvocationResult = class extends Schema2.Class("InvocationResult")({
   status: Schema2.Number,
   headers: Schema2.Record({ key: Schema2.String, value: Schema2.String }),
   data: Schema2.NullOr(Schema2.Unknown),
@@ -243,9 +292,7 @@ var extractParameters = (pathItem, operation, r) => {
       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
-      ),
+      allowReserved: Option2.fromNullable("allowReserved" in p ? p.allowReserved : void 0),
       description: Option2.fromNullable(p.description)
     })
   );
@@ -296,10 +343,7 @@ var buildInputSchema = (parameters, requestBody) => {
     additionalProperties: false
   };
 };
-var deriveOperationId = (method, pathTemplate, operation) => operation.operationId ?? (`${method}_${pathTemplate.replace(/[^a-zA-Z0-9]+/g, "_")}`.replace(
-  /^_+|_+$/g,
-  ""
-) || `${method}_operation`);
+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(
@@ -337,9 +381,7 @@ var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
       const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);
       operations.push(
         new ExtractedOperation({
-          operationId: OperationId.make(
-            deriveOperationId(method, pathTemplate, operation)
-          ),
+          operationId: OperationId.make(deriveOperationId(method, pathTemplate, operation)),
           method,
           pathTemplate,
           summary: Option2.fromNullable(operation.summary),
@@ -364,14 +406,11 @@ var extract = Effect2.fn("OpenApi.extract")(function* (doc) {
 
 // src/sdk/invoke.ts
 import { Effect as Effect3, Layer, Option as Option3 } from "effect";
-import {
-  HttpClient,
-  HttpClientRequest
-} from "@effect/platform";
+import { HttpClient, HttpClientRequest } from "@effect/platform";
 import {
   ToolInvocationResult,
   ToolInvocationError
-} from "@executor-js/sdk/core";
+} from "@executor-js/sdk";
 var CONTAINER_KEYS = {
   path: ["path", "pathParams", "params"],
   query: ["query", "queryParams", "params"],
@@ -404,19 +443,13 @@ var resolvePath = Effect3.fn("OpenApi.resolvePath")(function* (pathTemplate, arg
       }
       continue;
     }
-    resolved = resolved.replaceAll(
-      `{${param.name}}`,
-      encodeURIComponent(String(value))
-    );
+    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))
-      );
+      resolved = resolved.replaceAll(`{${name}}`, encodeURIComponent(String(value)));
     }
   }
   const unresolved = [...resolved.matchAll(/\{([^{}]+)\}/g)].map((m) => m[1]).filter((v) => typeof v === "string");
@@ -462,32 +495,20 @@ var isJsonContentType = (ct) => {
 };
 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 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)
-    );
+    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)
-    );
+    request = HttpClientRequest.setHeader(request, param.name, String(value));
   }
   if (Option3.isSome(operation.requestBody)) {
     const rb = operation.requestBody.value;
@@ -513,9 +534,7 @@ var invoke = Effect3.fn("OpenApi.invoke")(function* (operation, args, config, re
   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 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,
@@ -549,18 +568,12 @@ var makeOpenApiInvoker = (opts) => ({
     }
     const { binding, config } = entry;
     const baseUrl = config.baseUrl;
-    const resolvedHeaders = yield* resolveHeaders(
-      config.headers,
-      opts.secrets,
-      opts.scopeId
-    );
+    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)
-        )
+        HttpClient.mapRequest(HttpClientRequest.prependUrl(baseUrl))
       )
     ).pipe(Layer.provide(opts.httpClientLayer)) : opts.httpClientLayer;
     const result = yield* invoke(
@@ -591,30 +604,34 @@ var makeOpenApiInvoker = (opts) => ({
 });
 
 // src/sdk/kv-operation-store.ts
-import { Effect as Effect4, Schema as Schema3 } from "effect";
-import { scopeKv, makeInMemoryScopedKv } from "@executor-js/sdk/core";
-var StoredEntry = class extends Schema3.Class("StoredEntry")({
-  namespace: Schema3.String,
-  binding: OperationBinding,
-  config: InvocationConfig
-}) {
-};
-var encodeEntry = Schema3.encodeSync(Schema3.parseJson(StoredEntry));
-var decodeEntry = Schema3.decodeUnknownSync(Schema3.parseJson(StoredEntry));
-var StoredSourceSchema = Schema3.Struct({
+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 })
-    )
+    headers: Schema3.optional(Schema3.Record({ key: Schema3.String, value: HeaderValue }))
   })
-});
-var encodeSource = Schema3.encodeSync(Schema3.parseJson(StoredSourceSchema));
-var decodeSource = Schema3.decodeUnknownSync(Schema3.parseJson(StoredSourceSchema));
+}) {
+};
+
+// src/sdk/kv-operation-store.ts
+var StoredEntry = class extends Schema4.Class("StoredEntry")({
+  namespace: Schema4.String,
+  binding: OperationBinding,
+  config: InvocationConfig
+}) {
+};
+var encodeEntry = Schema4.encodeSync(Schema4.parseJson(StoredEntry));
+var decodeEntry = Schema4.decodeUnknownSync(Schema4.parseJson(StoredEntry));
+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;
   return {
@@ -626,16 +643,14 @@ var makeStore = (bindings, sources) => {
     }),
     put: (entries) => withKvTransaction(
       bindings,
-      Effect4.forEach(
-        entries,
-        ({ toolId, namespace, binding, config }) => bindings.set(
-          toolId,
-          encodeEntry(new StoredEntry({ namespace, binding, config }))
-        ),
-        { discard: true }
+      bindings.set(
+        entries.map(({ toolId, namespace, binding, config }) => ({
+          key: toolId,
+          value: encodeEntry(new StoredEntry({ namespace, binding, config }))
+        }))
       )
     ),
-    remove: (toolId) => bindings.delete(toolId).pipe(Effect4.asVoid),
+    remove: (toolId) => bindings.delete([toolId]).pipe(Effect4.asVoid),
     listByNamespace: (namespace) => Effect4.gen(function* () {
       const entries = yield* bindings.list();
       const ids = [];
@@ -650,73 +665,76 @@ var makeStore = (bindings, sources) => {
       const ids = [];
       for (const e of entries) {
         const entry = decodeEntry(e.value);
-        if (entry.namespace === namespace) {
-          ids.push(e.key);
-          yield* bindings.delete(e.key);
-        }
+        if (entry.namespace === namespace) ids.push(e.key);
       }
+      if (ids.length > 0) yield* bindings.delete(ids);
       return ids;
     }),
-    putSource: (source) => sources.set(source.namespace, encodeSource(source)),
-    removeSource: (namespace) => sources.delete(namespace).pipe(Effect4.asVoid),
+    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();
       return entries.map((e) => decodeSource(e.value));
+    }),
+    getSource: (namespace) => Effect4.gen(function* () {
+      const raw = yield* sources.get(namespace);
+      if (!raw) return null;
+      return decodeSource(raw);
+    }),
+    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()
-);
+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 Schema4 } from "effect";
-var SecurityScheme = class extends Schema4.Class("SecurityScheme")({
+import { Schema as Schema5 } from "effect";
+var SecurityScheme = class extends Schema5.Class("SecurityScheme")({
   /** Key name in components.securitySchemes (e.g. "api_token") */
-  name: Schema4.String,
+  name: Schema5.String,
   /** OpenAPI security scheme type */
-  type: Schema4.Literal("http", "apiKey", "oauth2", "openIdConnect"),
+  type: Schema5.Literal("http", "apiKey", "oauth2", "openIdConnect"),
   /** For type: "http" — e.g. "bearer", "basic" */
-  scheme: Schema4.optionalWith(Schema4.String, { as: "Option" }),
+  scheme: Schema5.optionalWith(Schema5.String, { as: "Option" }),
   /** For type: "apiKey" — where the key goes */
-  in: Schema4.optionalWith(Schema4.Literal("header", "query", "cookie"), { as: "Option" }),
+  in: Schema5.optionalWith(Schema5.Literal("header", "query", "cookie"), { as: "Option" }),
   /** For type: "apiKey" — the header/query/cookie name */
-  headerName: Schema4.optionalWith(Schema4.String, { as: "Option" }),
-  description: Schema4.optionalWith(Schema4.String, { as: "Option" })
+  headerName: Schema5.optionalWith(Schema5.String, { as: "Option" }),
+  description: Schema5.optionalWith(Schema5.String, { as: "Option" })
 }) {
 };
-var AuthStrategy = class extends Schema4.Class("AuthStrategy")({
+var AuthStrategy = class extends Schema5.Class("AuthStrategy")({
   /** The security schemes required together for this strategy */
-  schemes: Schema4.Array(Schema4.String)
+  schemes: Schema5.Array(Schema5.String)
 }) {
 };
-var HeaderPreset = class extends Schema4.Class("HeaderPreset")({
+var HeaderPreset = class extends Schema5.Class("HeaderPreset")({
   /** Human-readable label for the UI (e.g. "Bearer Token", "API Key + Email") */
-  label: Schema4.String,
+  label: Schema5.String,
   /** Headers this strategy needs. Value is null when the user must provide it. */
-  headers: Schema4.Record({ key: Schema4.String, value: Schema4.NullOr(Schema4.String) }),
+  headers: Schema5.Record({ key: Schema5.String, value: Schema5.NullOr(Schema5.String) }),
   /** Which headers should be stored as secrets */
-  secretHeaders: Schema4.Array(Schema4.String)
+  secretHeaders: Schema5.Array(Schema5.String)
 }) {
 };
-var SpecPreview = class extends Schema4.Class("SpecPreview")({
-  title: Schema4.optionalWith(Schema4.String, { as: "Option" }),
-  version: Schema4.optionalWith(Schema4.String, { as: "Option" }),
+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: Schema4.Array(Schema4.Unknown),
-  operationCount: Schema4.Number,
-  tags: Schema4.Array(Schema4.String),
-  securitySchemes: Schema4.Array(SecurityScheme),
+  servers: Schema5.Array(Schema5.Unknown),
+  operationCount: Schema5.Number,
+  tags: Schema5.Array(Schema5.String),
+  securitySchemes: Schema5.Array(SecurityScheme),
   /** Valid auth strategies (each is a set of schemes used together) */
-  authStrategies: Schema4.Array(AuthStrategy),
+  authStrategies: Schema5.Array(AuthStrategy),
   /** Pre-built header presets derived from auth strategies */
-  headerPresets: Schema4.Array(HeaderPreset)
+  headerPresets: Schema5.Array(HeaderPreset)
 }) {
 };
 var extractSecuritySchemes = (rawSchemes) => Object.entries(rawSchemes).flatMap(([name, schemeOrRef]) => {
@@ -730,9 +748,7 @@ var extractSecuritySchemes = (rawSchemes) => Object.entries(rawSchemes).flatMap(
       name,
       type,
       scheme: Option4.fromNullable(scheme.scheme),
-      in: Option4.fromNullable(
-        scheme.in
-      ),
+      in: Option4.fromNullable(scheme.in),
       headerName: Option4.fromNullable(scheme.name),
       description: Option4.fromNullable(scheme.description)
     })
@@ -767,13 +783,9 @@ var buildHeaderPresets = (schemes, strategies) => {
       }
     }
     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: [] })];
     }
-    return [
-      new HeaderPreset({ label: labelParts.join(" + "), headers, secretHeaders })
-    ];
+    return [new HeaderPreset({ label: labelParts.join(" + "), headers, secretHeaders })];
   });
 };
 var collectTags = (result) => {
@@ -786,9 +798,7 @@ var collectTags = (result) => {
 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 securitySchemes = extractSecuritySchemes(doc.components?.securitySchemes ?? {});
   const rawSecurity = doc.security ?? [];
   const authStrategies = rawSecurity.map(
     (entry) => new AuthStrategy({ schemes: Object.keys(entry) })
@@ -806,7 +816,7 @@ var previewSpec = Effect5.fn("OpenApi.previewSpec")(function* (specText) {
 });
 
 // src/sdk/plugin.ts
-import { Effect as Effect6, Option as Option5, Schema as Schema5 } from "effect";
+import { Effect as Effect6, Option as Option5, Schema as Schema6 } from "effect";
 import { FetchHttpClient } from "@effect/platform";
 import {
   Source,
@@ -815,7 +825,7 @@ import {
   registerRuntimeTools,
   runtimeTool,
   ToolId
-} from "@executor-js/sdk/core";
+} 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);
@@ -937,26 +947,22 @@ var compileToolDefinitions = (operations) => {
       operation: op
     };
   });
-  return resolveCollisions(raw).sort(
-    (a, b) => a.toolPath.localeCompare(b.toolPath)
-  );
+  return resolveCollisions(raw).sort((a, b) => a.toolPath.localeCompare(b.toolPath));
 };
 
 // src/sdk/plugin.ts
-var PreviewSpecInputSchema = Schema5.Struct({
-  spec: Schema5.String
+var PreviewSpecInputSchema = Schema6.Struct({
+  spec: Schema6.String
 });
-var AddSourceInputSchema = Schema5.Struct({
-  spec: Schema5.String,
-  baseUrl: Schema5.optional(Schema5.String),
-  namespace: Schema5.optional(Schema5.String),
-  headers: Schema5.optional(
-    Schema5.Record({ key: Schema5.String, value: HeaderValue })
-  )
+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 = Schema5.Struct({
-  sourceId: Schema5.String,
-  toolCount: Schema5.Number
+var AddSourceOutputSchema = Schema6.Struct({
+  sourceId: Schema6.String,
+  toolCount: Schema6.Number
 });
 var normalizeOpenApiRefs = (node) => {
   if (node == null || typeof node !== "object") return node;
@@ -988,10 +994,7 @@ var toRegistration = (def, namespace) => {
   const op = def.operation;
   const description = Option5.getOrElse(
     op.description,
-    () => Option5.getOrElse(
-      op.summary,
-      () => `${op.method.toUpperCase()} ${op.pathTemplate}`
-    )
+    () => Option5.getOrElse(op.summary, () => `${op.method.toUpperCase()} ${op.pathTemplate}`)
   );
   return {
     id: ToolId.make(`${namespace}.${def.toolPath}`),
@@ -1035,7 +1038,8 @@ var openApiPlugin = (options) => {
                 kind: "openapi",
                 runtime: false,
                 canRemove: true,
-                canRefresh: false
+                canRefresh: false,
+                canEdit: true
               })
             )
           )
@@ -1050,13 +1054,9 @@ var openApiPlugin = (options) => {
           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))
-          );
+          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))
-          );
+          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);
@@ -1086,9 +1086,7 @@ var openApiPlugin = (options) => {
           headers: config.headers ?? {}
         });
         const definitions = compileToolDefinitions(result.operations);
-        const registrations = definitions.map(
-          (def) => toRegistration(def, namespace)
-        );
+        const registrations = definitions.map((def) => toRegistration(def, namespace));
         yield* operationStore.put(
           definitions.map((def) => ({
             toolId: ToolId.make(`${namespace}.${def.toolPath}`),
@@ -1098,7 +1096,7 @@ var openApiPlugin = (options) => {
           }))
         );
         yield* ctx.tools.register(registrations);
-        const sourceName = Option5.getOrElse(result.title, () => namespace);
+        const sourceName = config.name ?? Option5.getOrElse(result.title, () => namespace);
         yield* operationStore.putSource({
           namespace,
           name: sourceName,
@@ -1142,15 +1140,48 @@ var openApiPlugin = (options) => {
       return {
         extension: {
           previewSpec: (specText) => previewSpec(specText),
-          addSpec: (config) => addSpecInternal(config).pipe(
-            Effect6.map(({ toolCount }) => ({ toolCount }))
-          ),
+          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 existingSource = yield* operationStore.getSourceConfig(namespace);
+            if (!existingSource) return;
+            const updatedConfig = {
+              ...existingSource,
+              ...input.baseUrl !== void 0 ? { baseUrl: input.baseUrl } : {},
+              ...input.headers !== void 0 ? { headers: input.headers } : {}
+            };
+            const newInvocationConfig = new InvocationConfig({
+              baseUrl: updatedConfig.baseUrl ?? resolveBaseUrl([]),
+              headers: updatedConfig.headers ?? {}
+            });
+            const toolIds = yield* operationStore.listByNamespace(namespace);
+            for (const toolId of toolIds) {
+              const entry = yield* operationStore.get(toolId);
+              if (entry) {
+                yield* operationStore.put([
+                  {
+                    toolId,
+                    namespace,
+                    binding: entry.binding,
+                    config: newInvocationConfig
+                  }
+                ]);
+              }
+            }
+            const sources = yield* operationStore.listSources();
+            const existingMeta = sources.find((s) => s.namespace === namespace);
+            yield* operationStore.putSource({
+              namespace,
+              name: existingMeta?.name ?? namespace,
+              config: updatedConfig
+            });
           })
         },
         close: () => runtimeTools.close()
@@ -1190,4 +1221,4 @@ export {
   previewSpec,
   openApiPlugin
 };
-//# sourceMappingURL=chunk-C57CSNPZ.js.map
+//# sourceMappingURL=chunk-V3D5A6HA.js.map