@executor-js/plugin-graphql 0.0.1 → 0.1.0

package/dist/chunk-AC5VPNLE.js

@@ -1,916 +0,0 @@
-// src/sdk/errors.ts
-import { Data, Schema } from "effect";
-var GraphqlIntrospectionError = class extends Schema.TaggedError()(
-  "GraphqlIntrospectionError",
-  {
-    message: Schema.String
-  }
-) {
-};
-var GraphqlExtractionError = class extends Schema.TaggedError()(
-  "GraphqlExtractionError",
-  {
-    message: Schema.String
-  }
-) {
-};
-var GraphqlInvocationError = class extends Data.TaggedError("GraphqlInvocationError") {
-};
-
-// src/sdk/introspect.ts
-import { Effect } from "effect";
-import { HttpClient, HttpClientRequest } from "@effect/platform";
-var INTROSPECTION_QUERY = `
-  query IntrospectionQuery {
-    __schema {
-      queryType { name }
-      mutationType { name }
-      types {
-        kind
-        name
-        description
-        fields(includeDeprecated: false) {
-          name
-          description
-          args {
-            name
-            description
-            type {
-              ...TypeRef
-            }
-            defaultValue
-          }
-          type {
-            ...TypeRef
-          }
-        }
-        inputFields {
-          name
-          description
-          type {
-            ...TypeRef
-          }
-          defaultValue
-        }
-        enumValues(includeDeprecated: false) {
-          name
-          description
-        }
-      }
-    }
-  }
-
-  fragment TypeRef on __Type {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-`;
-var introspect = Effect.fn("GraphQL.introspect")(function* (endpoint, headers) {
-  const client = yield* HttpClient.HttpClient;
-  let request = HttpClientRequest.post(endpoint).pipe(
-    HttpClientRequest.setHeader("Content-Type", "application/json"),
-    HttpClientRequest.bodyUnsafeJson({
-      query: INTROSPECTION_QUERY
-    })
-  );
-  if (headers) {
-    for (const [k, v] of Object.entries(headers)) {
-      request = HttpClientRequest.setHeader(request, k, v);
-    }
-  }
-  const response = yield* client.execute(request).pipe(
-    Effect.tapErrorCause((cause) => Effect.logError("graphql introspection request failed", cause)),
-    Effect.mapError(
-      (err) => new GraphqlIntrospectionError({
-        message: `Failed to reach GraphQL endpoint: ${err.message}`
-      })
-    )
-  );
-  if (response.status !== 200) {
-    return yield* new GraphqlIntrospectionError({
-      message: `Introspection failed with status ${response.status}`
-    });
-  }
-  const raw = yield* response.json.pipe(
-    Effect.tapErrorCause(
-      (cause) => Effect.logError("graphql introspection JSON parse failed", cause)
-    ),
-    Effect.mapError(
-      () => new GraphqlIntrospectionError({
-        message: `Failed to parse introspection response as JSON`
-      })
-    )
-  );
-  const json = raw;
-  if (json.errors && Array.isArray(json.errors) && json.errors.length > 0) {
-    return yield* new GraphqlIntrospectionError({
-      message: `Introspection returned ${json.errors.length} error(s)`
-    });
-  }
-  if (!json.data?.__schema) {
-    return yield* new GraphqlIntrospectionError({
-      message: "Introspection response missing __schema"
-    });
-  }
-  return json.data;
-});
-var parseIntrospectionJson = (text) => Effect.try({
-  try: () => {
-    const parsed = JSON.parse(text);
-    const result = parsed.data ?? parsed;
-    if (!result.__schema) {
-      throw new Error("Missing __schema in introspection JSON");
-    }
-    return result;
-  },
-  catch: (err) => new GraphqlIntrospectionError({
-    message: `Failed to parse introspection JSON: ${err instanceof Error ? err.message : String(err)}`
-  })
-});
-
-// src/sdk/types.ts
-import { Schema as Schema2 } from "effect";
-var GraphqlOperationKind = Schema2.Literal("query", "mutation");
-var GraphqlArgument = class extends Schema2.Class("GraphqlArgument")({
-  name: Schema2.String,
-  typeName: Schema2.String,
-  required: Schema2.Boolean,
-  description: Schema2.optionalWith(Schema2.String, { as: "Option" })
-}) {
-};
-var ExtractedField = class extends Schema2.Class("ExtractedField")({
-  /** e.g. "user", "createUser" */
-  fieldName: Schema2.String,
-  /** "query" or "mutation" */
-  kind: GraphqlOperationKind,
-  description: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  arguments: Schema2.Array(GraphqlArgument),
-  /** JSON Schema for the input (built from arguments) */
-  inputSchema: Schema2.optionalWith(Schema2.Unknown, { as: "Option" }),
-  /** The return type name for documentation */
-  returnTypeName: Schema2.String
-}) {
-};
-var ExtractionResult = class extends Schema2.Class("ExtractionResult")({
-  /** Schema name from introspection */
-  schemaName: Schema2.optionalWith(Schema2.String, { as: "Option" }),
-  fields: Schema2.Array(ExtractedField)
-}) {
-};
-var OperationBinding = class extends Schema2.Class("OperationBinding")({
-  kind: GraphqlOperationKind,
-  fieldName: Schema2.String,
-  /** The full GraphQL query/mutation string */
-  operationString: Schema2.String,
-  /** Ordered variable names for mapping */
-  variableNames: Schema2.Array(Schema2.String)
-}) {
-};
-var HeaderValue = Schema2.Union(
-  Schema2.String,
-  Schema2.Struct({
-    secretId: Schema2.String,
-    prefix: Schema2.optional(Schema2.String)
-  })
-);
-var InvocationConfig = class extends Schema2.Class("InvocationConfig")({
-  /** The GraphQL endpoint URL */
-  endpoint: 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,
-  data: Schema2.NullOr(Schema2.Unknown),
-  errors: Schema2.NullOr(Schema2.Unknown)
-}) {
-};
-
-// src/sdk/extract.ts
-import { Effect as Effect2, Option } from "effect";
-var unwrapTypeName = (ref) => {
-  if (ref.name) return ref.name;
-  if (ref.ofType) return unwrapTypeName(ref.ofType);
-  return "Unknown";
-};
-var isNonNull = (ref) => ref.kind === "NON_NULL";
-var buildDefinitions = (types) => {
-  const defs = {};
-  for (const [name, type] of types) {
-    if (name.startsWith("__")) continue;
-    if (type.kind === "INPUT_OBJECT" && type.inputFields) {
-      const properties = {};
-      const required = [];
-      for (const field of type.inputFields) {
-        const schema = typeRefToJsonSchema(field.type, types);
-        if (field.description) {
-          schema.description = field.description;
-        }
-        properties[field.name] = schema;
-        if (isNonNull(field.type)) {
-          required.push(field.name);
-        }
-      }
-      const def = { type: "object", properties };
-      if (required.length > 0) def.required = required;
-      if (type.description) def.description = type.description;
-      defs[name] = def;
-    }
-    if (type.kind === "ENUM" && type.enumValues) {
-      defs[name] = {
-        type: "string",
-        enum: type.enumValues.map((v) => v.name),
-        ...type.description ? { description: type.description } : {}
-      };
-    }
-  }
-  return defs;
-};
-var typeRefToJsonSchema = (ref, types) => {
-  switch (ref.kind) {
-    case "NON_NULL":
-      return ref.ofType ? typeRefToJsonSchema(ref.ofType, types) : {};
-    case "LIST":
-      return {
-        type: "array",
-        items: ref.ofType ? typeRefToJsonSchema(ref.ofType, types) : {}
-      };
-    case "SCALAR":
-      return scalarToJsonSchema(ref.name ?? "String");
-    case "ENUM":
-      return ref.name ? { $ref: `#/$defs/${ref.name}` } : { type: "string" };
-    case "INPUT_OBJECT":
-      return ref.name ? { $ref: `#/$defs/${ref.name}` } : { type: "object" };
-    case "OBJECT":
-    case "INTERFACE":
-    case "UNION":
-      return { type: "object" };
-    default:
-      return {};
-  }
-};
-var scalarToJsonSchema = (name) => {
-  switch (name) {
-    case "String":
-    case "ID":
-      return { type: "string" };
-    case "Int":
-      return { type: "integer" };
-    case "Float":
-      return { type: "number" };
-    case "Boolean":
-      return { type: "boolean" };
-    default:
-      return { type: "string", description: `Custom scalar: ${name}` };
-  }
-};
-var buildInputSchema = (args, types) => {
-  if (args.length === 0) return void 0;
-  const properties = {};
-  const required = [];
-  for (const arg of args) {
-    const schema = typeRefToJsonSchema(arg.type, types);
-    if (arg.description) {
-      schema.description = arg.description;
-    }
-    properties[arg.name] = schema;
-    if (isNonNull(arg.type)) {
-      required.push(arg.name);
-    }
-  }
-  const inputSchema = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) inputSchema.required = required;
-  return inputSchema;
-};
-var formatTypeRef = (ref) => {
-  switch (ref.kind) {
-    case "NON_NULL":
-      return ref.ofType ? `${formatTypeRef(ref.ofType)}!` : "Unknown!";
-    case "LIST":
-      return ref.ofType ? `[${formatTypeRef(ref.ofType)}]` : "[Unknown]";
-    default:
-      return ref.name ?? "Unknown";
-  }
-};
-var extractFields = (_schema, kind, typeName, types) => {
-  if (!typeName) return [];
-  const type = types.get(typeName);
-  if (!type?.fields) return [];
-  return type.fields.filter((f) => !f.name.startsWith("__")).map((field) => {
-    const args = field.args.map(
-      (arg) => new GraphqlArgument({
-        name: arg.name,
-        typeName: formatTypeRef(arg.type),
-        required: isNonNull(arg.type),
-        description: arg.description ? Option.some(arg.description) : Option.none()
-      })
-    );
-    const inputSchema = buildInputSchema(field.args, types);
-    return new ExtractedField({
-      fieldName: field.name,
-      kind,
-      description: field.description ? Option.some(field.description) : Option.none(),
-      arguments: args,
-      inputSchema: inputSchema ? Option.some(inputSchema) : Option.none(),
-      returnTypeName: unwrapTypeName(field.type)
-    });
-  });
-};
-var extract = (introspection) => Effect2.try({
-  try: () => {
-    const schema = introspection.__schema;
-    const typeMap = /* @__PURE__ */ new Map();
-    for (const t of schema.types) {
-      typeMap.set(t.name, t);
-    }
-    const definitions = buildDefinitions(typeMap);
-    const queryFields = extractFields(schema, "query", schema.queryType?.name, typeMap);
-    const mutationFields = extractFields(schema, "mutation", schema.mutationType?.name, typeMap);
-    return {
-      result: new ExtractionResult({
-        schemaName: Option.none(),
-        fields: [...queryFields, ...mutationFields]
-      }),
-      definitions
-    };
-  },
-  catch: (err) => new GraphqlExtractionError({
-    message: `Failed to extract GraphQL schema: ${err instanceof Error ? err.message : String(err)}`
-  })
-});
-
-// src/sdk/invoke.ts
-import { Effect as Effect3, Option as Option2 } from "effect";
-import { HttpClient as HttpClient2, HttpClientRequest as HttpClientRequest2 } from "@effect/platform";
-import {
-  ToolInvocationResult,
-  ToolInvocationError
-} from "@executor-js/sdk";
-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 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("GraphQL.invoke")(function* (operation, args, config, resolvedHeaders) {
-  const client = yield* HttpClient2.HttpClient;
-  const variables = {};
-  for (const varName of operation.variableNames) {
-    if (args[varName] !== void 0) {
-      variables[varName] = args[varName];
-    }
-  }
-  if (typeof args.variables === "object" && args.variables !== null) {
-    Object.assign(variables, args.variables);
-  }
-  let request = HttpClientRequest2.post(config.endpoint).pipe(
-    HttpClientRequest2.setHeader("Content-Type", "application/json"),
-    HttpClientRequest2.bodyUnsafeJson({
-      query: operation.operationString,
-      variables: Object.keys(variables).length > 0 ? variables : void 0
-    })
-  );
-  if (resolvedHeaders) {
-    for (const [name, value] of Object.entries(resolvedHeaders)) {
-      request = HttpClientRequest2.setHeader(request, name, value);
-    }
-  }
-  const response = yield* client.execute(request).pipe(
-    Effect3.mapError(
-      (err) => new GraphqlInvocationError({
-        message: `GraphQL request failed: ${err.message}`,
-        statusCode: Option2.none(),
-        cause: err
-      })
-    )
-  );
-  const status = response.status;
-  const contentType = response.headers["content-type"] ?? null;
-  const body = isJsonContentType(contentType) ? yield* response.json.pipe(Effect3.catchAll(() => response.text)) : yield* response.text;
-  const gqlBody = body;
-  const hasErrors = Array.isArray(gqlBody?.errors) && gqlBody.errors.length > 0;
-  return new InvocationResult({
-    status,
-    data: gqlBody?.data ?? null,
-    errors: hasErrors ? gqlBody.errors : null
-  });
-});
-var makeGraphqlInvoker = (opts) => ({
-  resolveAnnotations: (toolId) => Effect3.gen(function* () {
-    const entry = yield* opts.operationStore.get(toolId);
-    if (!entry) return void 0;
-    if (entry.binding.kind === "mutation") {
-      return {
-        requiresApproval: true,
-        approvalDescription: `mutation ${entry.binding.fieldName}`
-      };
-    }
-    return {};
-  }),
-  invoke: (toolId, args) => Effect3.gen(function* () {
-    const entry = yield* opts.operationStore.get(toolId);
-    if (!entry) {
-      return yield* new ToolInvocationError({
-        toolId,
-        message: `No GraphQL 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 resolvedHeaders = yield* resolveHeaders(config.headers, opts.secrets, opts.scopeId);
-    const result = yield* invoke(
-      binding,
-      args ?? {},
-      config,
-      resolvedHeaders
-    ).pipe(Effect3.provide(opts.httpClientLayer));
-    return new ToolInvocationResult({
-      data: result.data,
-      error: result.errors,
-      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: `GraphQL 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("GraphqlStoredSource")({
-  namespace: Schema3.String,
-  name: Schema3.String,
-  config: Schema3.Struct({
-    endpoint: Schema3.String,
-    introspectionJson: 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 encodeSource = Schema4.encodeSync(Schema4.parseJson(StoredSourceSchema));
-var decodeSource = Schema4.decodeUnknownSync(Schema4.parseJson(StoredSourceSchema));
-var rehydrate = (source) => source.invocationConfig ? source : {
-  ...source,
-  invocationConfig: new InvocationConfig({
-    endpoint: source.config.endpoint,
-    headers: source.config.headers ?? {}
-  })
-};
-var makeStore = (bindings, sources) => ({
-  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: (toolId, namespace, binding) => bindings.set([
-    { 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();
-    return entries.map((e) => rehydrate(decodeSource(e.value)));
-  }),
-  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 = rehydrate(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/plugin.ts
-import { Effect as Effect5, Option as Option3, Schema as Schema5 } from "effect";
-import { FetchHttpClient } from "@effect/platform";
-import {
-  Source,
-  SourceDetectionResult,
-  definePlugin,
-  registerRuntimeTools,
-  runtimeTool,
-  ToolId
-} from "@executor-js/sdk";
-var AddSourceInputSchema = Schema5.Struct({
-  endpoint: Schema5.String,
-  name: Schema5.optional(Schema5.String),
-  introspectionJson: Schema5.optional(Schema5.String),
-  namespace: Schema5.optional(Schema5.String),
-  headers: Schema5.optional(Schema5.Record({ key: Schema5.String, value: HeaderValue }))
-});
-var AddSourceOutputSchema = Schema5.Struct({
-  sourceId: Schema5.String,
-  toolCount: Schema5.Number
-});
-var namespaceFromEndpoint = (endpoint) => {
-  try {
-    const url = new URL(endpoint);
-    return url.hostname.replace(/[^a-z0-9]+/gi, "_").toLowerCase();
-  } catch {
-    return "graphql";
-  }
-};
-var buildOperationStringForField = (kind, field, types) => {
-  const opType = kind === "query" ? "query" : "mutation";
-  const varDefs = field.args.map((arg) => {
-    const typeName = formatTypeRef2(arg.type);
-    return `$${arg.name}: ${typeName}`;
-  });
-  const argPasses = field.args.map((arg) => `${arg.name}: $${arg.name}`);
-  const selectionSet = buildSelectionSet(field.type, types, 0, /* @__PURE__ */ new Set());
-  const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(", ")})` : "";
-  const argPassStr = argPasses.length > 0 ? `(${argPasses.join(", ")})` : "";
-  return `${opType}${varDefsStr} { ${field.name}${argPassStr}${selectionSet ? ` ${selectionSet}` : ""} }`;
-};
-var formatTypeRef2 = (ref) => {
-  switch (ref.kind) {
-    case "NON_NULL":
-      return ref.ofType ? `${formatTypeRef2(ref.ofType)}!` : "Unknown!";
-    case "LIST":
-      return ref.ofType ? `[${formatTypeRef2(ref.ofType)}]` : "[Unknown]";
-    default:
-      return ref.name ?? "Unknown";
-  }
-};
-var unwrapTypeName2 = (ref) => {
-  if (ref.name) return ref.name;
-  if (ref.ofType) return unwrapTypeName2(ref.ofType);
-  return "Unknown";
-};
-var buildSelectionSet = (ref, types, depth, seen) => {
-  if (depth > 2) return "";
-  const leafName = unwrapTypeName2(ref);
-  if (seen.has(leafName)) return "";
-  const objectType = types.get(leafName);
-  if (!objectType?.fields) return "";
-  const kind = objectType.kind;
-  if (kind === "SCALAR" || kind === "ENUM") return "";
-  seen.add(leafName);
-  const subFields = objectType.fields.filter((f) => !f.name.startsWith("__")).slice(0, 12).map((f) => {
-    const sub = buildSelectionSet(f.type, types, depth + 1, seen);
-    return sub ? `${f.name} ${sub}` : f.name;
-  });
-  seen.delete(leafName);
-  return subFields.length > 0 ? `{ ${subFields.join(" ")} }` : "";
-};
-var toRegistration = (field, namespace) => {
-  const prefix = field.kind === "mutation" ? "mutation" : "query";
-  const toolPath = `${prefix}.${field.fieldName}`;
-  const description = Option3.getOrElse(
-    field.description,
-    () => `GraphQL ${field.kind}: ${field.fieldName} -> ${field.returnTypeName}`
-  );
-  return {
-    id: ToolId.make(`${namespace}.${toolPath}`),
-    pluginKey: "graphql",
-    sourceId: namespace,
-    name: toolPath,
-    description,
-    inputSchema: Option3.getOrUndefined(field.inputSchema),
-    outputSchema: void 0
-  };
-};
-var graphqlPlugin = (options) => {
-  const httpClientLayer = options?.httpClientLayer ?? FetchHttpClient.layer;
-  const operationStore = options?.operationStore ?? makeInMemoryOperationStore();
-  return definePlugin({
-    key: "graphql",
-    init: (ctx) => Effect5.gen(function* () {
-      yield* ctx.tools.registerInvoker(
-        "graphql",
-        makeGraphqlInvoker({
-          operationStore,
-          httpClientLayer,
-          secrets: ctx.secrets,
-          scopeId: ctx.scope.id
-        })
-      );
-      yield* ctx.sources.addManager({
-        kind: "graphql",
-        list: () => operationStore.listSources().pipe(
-          Effect5.map(
-            (metas) => metas.map(
-              (s) => new Source({
-                id: s.namespace,
-                name: s.name,
-                kind: "graphql",
-                url: s.config.endpoint,
-                runtime: false,
-                canRemove: true,
-                canRefresh: false,
-                canEdit: true
-              })
-            )
-          )
-        ),
-        remove: (sourceId) => Effect5.gen(function* () {
-          yield* operationStore.removeByNamespace(sourceId);
-          yield* operationStore.removeSource(sourceId);
-          yield* ctx.tools.unregisterBySource(sourceId);
-        }),
-        detect: (url) => Effect5.gen(function* () {
-          const trimmed = url.trim();
-          if (!trimmed) return null;
-          const parsed = yield* Effect5.try(() => new URL(trimmed)).pipe(Effect5.option);
-          if (parsed._tag === "None") return null;
-          const ok = yield* introspect(trimmed).pipe(
-            Effect5.provide(httpClientLayer),
-            Effect5.map(() => true),
-            Effect5.catchAll(() => Effect5.succeed(false))
-          );
-          if (!ok) return null;
-          const name = namespaceFromEndpoint(trimmed);
-          return new SourceDetectionResult({
-            kind: "graphql",
-            confidence: "high",
-            endpoint: trimmed,
-            name,
-            namespace: name
-          });
-        })
-      });
-      const addSourceInternal = (config) => Effect5.gen(function* () {
-        let introspectionResult;
-        if (config.introspectionJson) {
-          introspectionResult = yield* parseIntrospectionJson(config.introspectionJson);
-        } else {
-          const resolvedHeaders = {};
-          if (config.headers) {
-            for (const [name, value] of Object.entries(config.headers)) {
-              if (typeof value === "string") {
-                resolvedHeaders[name] = value;
-              } else {
-                const secret = yield* ctx.secrets.resolve(value.secretId, ctx.scope.id).pipe(Effect5.catchAll(() => Effect5.succeed("")));
-                if (secret) {
-                  resolvedHeaders[name] = value.prefix ? `${value.prefix}${secret}` : secret;
-                }
-              }
-            }
-          }
-          introspectionResult = yield* introspect(
-            config.endpoint,
-            Object.keys(resolvedHeaders).length > 0 ? resolvedHeaders : void 0
-          ).pipe(Effect5.provide(httpClientLayer));
-        }
-        const { result, definitions } = yield* extract(introspectionResult);
-        const namespace = config.namespace ?? namespaceFromEndpoint(config.endpoint);
-        if (Object.keys(definitions).length > 0) {
-          yield* ctx.tools.registerDefinitions(definitions);
-        }
-        const invocationConfig = new InvocationConfig({
-          endpoint: config.endpoint,
-          headers: config.headers ?? {}
-        });
-        const typeMap = /* @__PURE__ */ new Map();
-        for (const t of introspectionResult.__schema.types) {
-          typeMap.set(t.name, t);
-        }
-        const fieldMap = /* @__PURE__ */ new Map();
-        const schema = introspectionResult.__schema;
-        for (const rootKind of ["query", "mutation"]) {
-          const typeName = rootKind === "query" ? schema.queryType?.name : schema.mutationType?.name;
-          if (!typeName) continue;
-          const rootType = typeMap.get(typeName);
-          if (!rootType?.fields) continue;
-          for (const f of rootType.fields) {
-            if (!f.name.startsWith("__")) {
-              fieldMap.set(`${rootKind}.${f.name}`, { kind: rootKind, field: f });
-            }
-          }
-        }
-        const registrations = [];
-        yield* Effect5.forEach(
-          result.fields,
-          (extractedField) => {
-            const reg = toRegistration(extractedField, namespace);
-            registrations.push(reg);
-            const key = `${extractedField.kind}.${extractedField.fieldName}`;
-            const entry = fieldMap.get(key);
-            const operationString = entry ? buildOperationStringForField(entry.kind, entry.field, typeMap) : `${extractedField.kind} { ${extractedField.fieldName} }`;
-            const binding = new OperationBinding({
-              kind: extractedField.kind,
-              fieldName: extractedField.fieldName,
-              operationString,
-              variableNames: extractedField.arguments.map((a) => a.name)
-            });
-            return operationStore.put(reg.id, namespace, binding);
-          },
-          { discard: true }
-        );
-        yield* ctx.tools.register(registrations);
-        yield* operationStore.putSource({
-          namespace,
-          name: config.name?.trim() || namespace,
-          config: {
-            endpoint: config.endpoint,
-            introspectionJson: config.introspectionJson,
-            namespace: config.namespace,
-            headers: config.headers
-          },
-          invocationConfig
-        });
-        return { sourceId: namespace, toolCount: registrations.length };
-      });
-      const runtimeTools = yield* registerRuntimeTools({
-        registry: ctx.tools,
-        sources: ctx.sources,
-        pluginKey: "graphql",
-        source: {
-          id: "built-in",
-          name: "Built In",
-          kind: "built-in"
-        },
-        tools: [
-          runtimeTool({
-            id: "graphql.addSource",
-            name: "graphql.addSource",
-            description: "Add a GraphQL endpoint and register its operations as tools",
-            inputSchema: AddSourceInputSchema,
-            outputSchema: AddSourceOutputSchema,
-            handler: (input) => addSourceInternal(input)
-          })
-        ]
-      });
-      return {
-        extension: {
-          addSource: (config) => addSourceInternal(config).pipe(
-            Effect5.map(({ toolCount }) => ({ toolCount })),
-            Effect5.mapError(
-              (err) => new GraphqlExtractionError({
-                message: err instanceof Error ? err.message : String(err)
-              })
-            )
-          ),
-          removeSource: (namespace) => Effect5.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) => Effect5.gen(function* () {
-            const existing = yield* operationStore.getSource(namespace);
-            if (!existing) return;
-            const updatedConfig = {
-              ...existing.config,
-              ...input.endpoint !== void 0 ? { endpoint: input.endpoint } : {},
-              ...input.headers !== void 0 ? { headers: input.headers } : {}
-            };
-            const newInvocationConfig = new InvocationConfig({
-              endpoint: updatedConfig.endpoint,
-              headers: updatedConfig.headers ?? {}
-            });
-            yield* operationStore.putSource({
-              namespace,
-              name: input.name?.trim() || existing.name,
-              config: updatedConfig,
-              invocationConfig: newInvocationConfig
-            });
-          })
-        },
-        close: () => runtimeTools.close()
-      };
-    })
-  });
-};
-
-export {
-  GraphqlIntrospectionError,
-  GraphqlExtractionError,
-  GraphqlInvocationError,
-  introspect,
-  parseIntrospectionJson,
-  GraphqlOperationKind,
-  GraphqlArgument,
-  ExtractedField,
-  ExtractionResult,
-  OperationBinding,
-  HeaderValue,
-  InvocationConfig,
-  InvocationResult,
-  extract,
-  invoke,
-  makeGraphqlInvoker,
-  makeKvOperationStore,
-  makeInMemoryOperationStore,
-  graphqlPlugin
-};
-//# sourceMappingURL=chunk-AC5VPNLE.js.map