@executor-js/sdk 0.0.1 → 0.0.2

package/dist/chunk-D7CT3UMO.js

@@ -1,1386 +0,0 @@
-// src/ids.ts
-import { Schema } from "effect";
-var ScopeId = Schema.String.pipe(Schema.brand("ScopeId"));
-var ToolId = Schema.String.pipe(Schema.brand("ToolId"));
-var SecretId = Schema.String.pipe(Schema.brand("SecretId"));
-var PolicyId = Schema.String.pipe(Schema.brand("PolicyId"));
-
-// src/errors.ts
-import { Data, Schema as Schema2 } from "effect";
-var ToolNotFoundError = class extends Schema2.TaggedError()(
-  "ToolNotFoundError",
-  { toolId: ToolId }
-) {
-};
-var ToolInvocationError = class extends Data.TaggedError("ToolInvocationError") {
-};
-var SecretNotFoundError = class extends Schema2.TaggedError()(
-  "SecretNotFoundError",
-  { secretId: SecretId }
-) {
-};
-var SecretResolutionError = class extends Schema2.TaggedError()(
-  "SecretResolutionError",
-  {
-    secretId: SecretId,
-    message: Schema2.String
-  }
-) {
-};
-var PolicyDeniedError = class extends Schema2.TaggedError()(
-  "PolicyDeniedError",
-  {
-    policyId: PolicyId,
-    toolId: ToolId,
-    reason: Schema2.String
-  }
-) {
-};
-
-// src/tools.ts
-import { Context, Schema as Schema3 } from "effect";
-var ToolAnnotations = class extends Schema3.Class("ToolAnnotations")({
-  /** Whether this tool requires user approval before execution */
-  requiresApproval: Schema3.optional(Schema3.Boolean),
-  /** Human-readable description shown in the approval prompt */
-  approvalDescription: Schema3.optional(Schema3.String)
-}) {
-};
-var ToolMetadata = class extends Schema3.Class("ToolMetadata")({
-  id: ToolId,
-  pluginKey: Schema3.String,
-  /** Source this tool belongs to (namespace identifier) */
-  sourceId: Schema3.String,
-  name: Schema3.String,
-  description: Schema3.optional(Schema3.String),
-  /** Whether this tool may request elicitation during invocation */
-  mayElicit: Schema3.optional(Schema3.Boolean)
-}) {
-};
-var ToolSchema = class extends Schema3.Class("ToolSchema")({
-  id: ToolId,
-  inputTypeScript: Schema3.optional(Schema3.String),
-  outputTypeScript: Schema3.optional(Schema3.String),
-  typeScriptDefinitions: Schema3.optional(
-    Schema3.Record({ key: Schema3.String, value: Schema3.String })
-  ),
-  inputSchema: Schema3.optional(Schema3.Unknown),
-  outputSchema: Schema3.optional(Schema3.Unknown)
-}) {
-};
-var ToolInvocationResult = class extends Schema3.Class(
-  "ToolInvocationResult"
-)({
-  data: Schema3.Unknown,
-  error: Schema3.NullOr(Schema3.Unknown),
-  status: Schema3.optional(Schema3.Number)
-}) {
-};
-var ToolListFilter = class extends Schema3.Class("ToolListFilter")({
-  /** Filter to tools belonging to a specific source */
-  sourceId: Schema3.optional(Schema3.String),
-  query: Schema3.optional(Schema3.String)
-}) {
-};
-var ToolRegistry = class extends Context.Tag("@executor-js/sdk/ToolRegistry")() {
-};
-var ToolRegistration = class extends Schema3.Class("ToolRegistration")({
-  id: ToolId,
-  pluginKey: Schema3.String,
-  /** Source this tool belongs to (namespace identifier) */
-  sourceId: Schema3.String,
-  name: Schema3.String,
-  description: Schema3.optional(Schema3.String),
-  mayElicit: Schema3.optional(Schema3.Boolean),
-  inputSchema: Schema3.optional(Schema3.Unknown),
-  outputSchema: Schema3.optional(Schema3.Unknown)
-}) {
-};
-
-// src/sources.ts
-import { Context as Context2, Effect as Effect2, Schema as Schema4 } from "effect";
-var Source = class extends Schema4.Class("Source")({
-  /** Unique namespace identifier (e.g. "github_rest") */
-  id: Schema4.String,
-  /** Human-readable name */
-  name: Schema4.String,
-  /** Plugin kind that manages this source (e.g. "openapi", "mcp") */
-  kind: Schema4.String,
-  /** Optional upstream URL for this source — used to derive a favicon in the UI */
-  url: Schema4.optional(Schema4.String),
-  /** True when the source is provided by the running executor */
-  runtime: Schema4.optional(Schema4.Boolean),
-  /** Whether the source supports removal */
-  canRemove: Schema4.optional(Schema4.Boolean),
-  /** Whether the source supports refresh */
-  canRefresh: Schema4.optional(Schema4.Boolean),
-  /** Whether the source supports editing (config changes) */
-  canEdit: Schema4.optional(Schema4.Boolean)
-}) {
-};
-var SourceDetectionResult = class extends Schema4.Class(
-  "SourceDetectionResult"
-)({
-  /** Plugin kind that detected this source */
-  kind: Schema4.String,
-  /** How confident the plugin is that the URL matches */
-  confidence: Schema4.Literal("high", "medium", "low"),
-  /** The URL that was probed */
-  endpoint: Schema4.String,
-  /** Suggested human-readable name */
-  name: Schema4.String,
-  /** Suggested namespace */
-  namespace: Schema4.String
-}) {
-};
-var SourceRegistry = class extends Context2.Tag("@executor-js/sdk/SourceRegistry")() {
-};
-var makeInMemorySourceRegistry = () => {
-  const managers = /* @__PURE__ */ new Map();
-  const runtimeSources = /* @__PURE__ */ new Map();
-  return {
-    addManager: (manager) => Effect2.sync(() => {
-      managers.set(manager.kind, manager);
-    }),
-    registerRuntime: (source) => Effect2.sync(() => {
-      runtimeSources.set(source.id, source);
-    }),
-    unregisterRuntime: (sourceId) => Effect2.sync(() => {
-      runtimeSources.delete(sourceId);
-    }),
-    list: () => Effect2.gen(function* () {
-      const all = [...runtimeSources.values()];
-      for (const manager of managers.values()) {
-        const sources = yield* manager.list();
-        all.push(...sources);
-      }
-      return all;
-    }),
-    remove: (sourceId) => Effect2.gen(function* () {
-      const runtimeSource = runtimeSources.get(sourceId);
-      if (runtimeSource) {
-        if (runtimeSource.canRemove) {
-          runtimeSources.delete(sourceId);
-        }
-        return;
-      }
-      for (const manager of managers.values()) {
-        const sources = yield* manager.list();
-        if (sources.some((s) => s.id === sourceId)) {
-          yield* manager.remove(sourceId);
-          return;
-        }
-      }
-    }),
-    refresh: (sourceId) => Effect2.gen(function* () {
-      const runtimeSource = runtimeSources.get(sourceId);
-      if (runtimeSource) {
-        return;
-      }
-      for (const manager of managers.values()) {
-        const sources = yield* manager.list();
-        if (sources.some((s) => s.id === sourceId)) {
-          if (manager.refresh) {
-            yield* manager.refresh(sourceId);
-          }
-          return;
-        }
-      }
-    }),
-    detect: (url) => Effect2.gen(function* () {
-      const detectors = [...managers.values()].filter((m) => m.detect).map(
-        (m) => m.detect(url).pipe(
-          Effect2.timeout("5 seconds"),
-          Effect2.catchAll(() => Effect2.succeed(null))
-        )
-      );
-      const results = yield* Effect2.all(detectors, { concurrency: "unbounded" });
-      return results.filter((r) => r !== null).sort((a, b) => {
-        const order = { high: 0, medium: 1, low: 2 };
-        return order[a.confidence] - order[b.confidence];
-      });
-    })
-  };
-};
-
-// src/elicitation.ts
-import { Schema as Schema5 } from "effect";
-var FormElicitation = class extends Schema5.TaggedClass()("FormElicitation", {
-  message: Schema5.String,
-  /** JSON Schema describing the fields to collect */
-  requestedSchema: Schema5.Record({ key: Schema5.String, value: Schema5.Unknown })
-}) {
-};
-var UrlElicitation = class extends Schema5.TaggedClass()("UrlElicitation", {
-  message: Schema5.String,
-  url: Schema5.String,
-  /** Unique ID so the host can correlate the callback */
-  elicitationId: Schema5.String
-}) {
-};
-var ElicitationAction = Schema5.Literal("accept", "decline", "cancel");
-var ElicitationResponse = class extends Schema5.Class("ElicitationResponse")({
-  action: ElicitationAction,
-  /** Present when action is "accept" — the data the user provided */
-  content: Schema5.optional(Schema5.Record({ key: Schema5.String, value: Schema5.Unknown }))
-}) {
-};
-var ElicitationDeclinedError = class extends Schema5.TaggedError()(
-  "ElicitationDeclinedError",
-  {
-    toolId: ToolId,
-    action: Schema5.Literal("decline", "cancel")
-  }
-) {
-};
-
-// src/secrets.ts
-import { Context as Context3, Schema as Schema6 } from "effect";
-var SecretRef = class extends Schema6.Class("SecretRef")({
-  id: SecretId,
-  scopeId: ScopeId,
-  /** Human-readable label (e.g. "Cloudflare API Token") */
-  name: Schema6.String,
-  /** Optional: pin to a specific provider */
-  provider: Schema6.optionalWith(Schema6.String, { as: "Option" }),
-  /** What this secret is for */
-  purpose: Schema6.optional(Schema6.String),
-  createdAt: Schema6.DateFromNumber
-}) {
-};
-var SetSecretInput = class extends Schema6.Class("SetSecretInput")({
-  id: SecretId,
-  scopeId: ScopeId,
-  name: Schema6.String,
-  value: Schema6.String,
-  provider: Schema6.optional(Schema6.String),
-  purpose: Schema6.optional(Schema6.String)
-}) {
-};
-var SecretStore = class extends Context3.Tag("@executor-js/sdk/SecretStore")() {
-};
-
-// src/policies.ts
-import { Context as Context4, Schema as Schema7 } from "effect";
-var PolicyAction = Schema7.Literal("allow", "deny", "require_approval");
-var Policy = class extends Schema7.Class("Policy")({
-  id: PolicyId,
-  scopeId: ScopeId,
-  name: Schema7.String,
-  action: PolicyAction,
-  match: Schema7.Struct({
-    toolPattern: Schema7.optional(Schema7.String),
-    sourceId: Schema7.optional(Schema7.String)
-  }),
-  priority: Schema7.Number,
-  createdAt: Schema7.DateFromNumber
-}) {
-};
-var PolicyCheckInput = class extends Schema7.Class("PolicyCheckInput")({
-  scopeId: ScopeId,
-  toolId: ToolId
-}) {
-};
-var PolicyEngine = class extends Context4.Tag("@executor-js/sdk/PolicyEngine")() {
-};
-
-// src/scope.ts
-import { Schema as Schema8 } from "effect";
-var Scope = class extends Schema8.Class("Scope")({
-  id: ScopeId,
-  name: Schema8.String,
-  createdAt: Schema8.DateFromNumber
-}) {
-};
-
-// src/plugin.ts
-var definePlugin = (plugin) => plugin;
-
-// src/executor.ts
-import { Effect as Effect6 } from "effect";
-var resolveElicitationHandler = (options) => options.onElicitation === "accept-all" ? () => Effect6.succeed(new ElicitationResponse({ action: "accept" })) : options.onElicitation;
-var createExecutor = (config) => Effect6.gen(function* () {
-  const { scope, tools, sources, secrets, policies, plugins = [] } = config;
-  const handles = /* @__PURE__ */ new Map();
-  const extensions = {};
-  for (const plugin of plugins) {
-    const handle = yield* plugin.init({
-      scope,
-      tools,
-      sources,
-      secrets,
-      policies
-    });
-    handles.set(plugin.key, handle);
-    extensions[plugin.key] = handle.extension;
-  }
-  const base = {
-    scope,
-    tools: {
-      list: (filter) => tools.list(filter),
-      schema: (toolId) => tools.schema(toolId),
-      definitions: () => tools.definitions(),
-      invoke: (toolId, args, options) => {
-        const tid = toolId;
-        return Effect6.gen(function* () {
-          yield* policies.check({ scopeId: scope.id, toolId: tid });
-          const annotations = yield* tools.resolveAnnotations(tid);
-          if (annotations?.requiresApproval) {
-            const handler = resolveElicitationHandler(options);
-            const response = yield* handler({
-              toolId: tid,
-              args,
-              request: new FormElicitation({
-                message: annotations.approvalDescription ?? `Approve ${toolId}?`,
-                requestedSchema: {}
-              })
-            });
-            if (response.action !== "accept") {
-              return yield* new ElicitationDeclinedError({
-                toolId: tid,
-                action: response.action
-              });
-            }
-          }
-          return yield* tools.invoke(tid, args, options);
-        });
-      }
-    },
-    sources: {
-      list: () => sources.list(),
-      remove: (sourceId) => sources.remove(sourceId),
-      refresh: (sourceId) => sources.refresh(sourceId),
-      detect: (url) => sources.detect(url)
-    },
-    policies: {
-      list: () => policies.list(scope.id),
-      add: (policy) => policies.add({ ...policy, scopeId: scope.id }),
-      remove: (policyId) => policies.remove(policyId)
-    },
-    secrets: {
-      list: () => secrets.list(scope.id),
-      resolve: (secretId) => secrets.resolve(secretId, scope.id),
-      status: (secretId) => secrets.status(secretId, scope.id),
-      set: (input) => secrets.set({ ...input, scopeId: scope.id }),
-      remove: (secretId) => secrets.remove(secretId),
-      addProvider: (provider) => secrets.addProvider(provider),
-      providers: () => secrets.providers()
-    },
-    close: () => Effect6.gen(function* () {
-      for (const handle of handles.values()) {
-        if (handle.close) yield* handle.close();
-      }
-    })
-  };
-  return Object.assign(base, extensions);
-});
-
-// src/plugins/in-memory-tools.ts
-import { Effect as Effect7, JSONSchema, Schema as Schema9 } from "effect";
-
-// src/schema-refs.ts
-var REF_PATTERN = /^#\/(?:\$defs|definitions)\/(.+)$/;
-var parseRefName = (ref) => ref.match(REF_PATTERN)?.[1];
-var normalizeRefs = (node) => {
-  if (node == null || typeof node !== "object") return node;
-  if (Array.isArray(node)) {
-    let changed2 = false;
-    const out = node.map((item) => {
-      const n = normalizeRefs(item);
-      if (n !== item) changed2 = true;
-      return n;
-    });
-    return changed2 ? out : node;
-  }
-  const obj = node;
-  if (typeof obj.$ref === "string") {
-    const name = parseRefName(obj.$ref);
-    if (name) {
-      const canonical = `#/$defs/${name}`;
-      return canonical !== obj.$ref ? { ...obj, $ref: canonical } : obj;
-    }
-    return obj;
-  }
-  let changed = false;
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    const n = normalizeRefs(v);
-    if (n !== v) changed = true;
-    result[k] = n;
-  }
-  return changed ? result : obj;
-};
-var hoistDefinitions = (schema) => {
-  if (schema == null || typeof schema !== "object") {
-    return { stripped: schema, defs: {} };
-  }
-  const obj = schema;
-  const defs = {};
-  if (obj.$defs && typeof obj.$defs === "object") {
-    for (const [k, v] of Object.entries(obj.$defs)) {
-      defs[k] = v;
-    }
-  }
-  if (obj.definitions && typeof obj.definitions === "object") {
-    for (const [k, v] of Object.entries(obj.definitions)) {
-      defs[k] = v;
-    }
-  }
-  const { $defs: _a, definitions: _b, ...rest } = obj;
-  return { stripped: rest, defs };
-};
-var collectRefs = (node, defs, found = /* @__PURE__ */ new Set()) => {
-  if (node == null || typeof node !== "object") return found;
-  const obj = node;
-  if (typeof obj.$ref === "string") {
-    const name = parseRefName(obj.$ref);
-    if (name && !found.has(name)) {
-      found.add(name);
-      const def = defs.get(name);
-      if (def) collectRefs(def, defs, found);
-    }
-    return found;
-  }
-  for (const v of Object.values(obj)) {
-    if (v && typeof v === "object") {
-      if (Array.isArray(v)) {
-        for (const item of v) collectRefs(item, defs, found);
-      } else {
-        collectRefs(v, defs, found);
-      }
-    }
-  }
-  return found;
-};
-var reattachDefs = (schema, defs) => {
-  if (schema == null || typeof schema !== "object") return schema;
-  const refs = collectRefs(schema, defs);
-  if (refs.size === 0) return schema;
-  const attached = {};
-  for (const name of refs) {
-    const def = defs.get(name);
-    if (def) attached[name] = def;
-  }
-  return { ...schema, $defs: attached };
-};
-
-// src/plugins/in-memory-tools.ts
-var buildRegistration = (namespace, def) => {
-  const id = ToolId.make(`${namespace}.${def.name}`);
-  const decode = Schema9.decodeUnknownSync(def.inputSchema);
-  const isEffect = def.handler.length >= 2;
-  const inputJson = JSONSchema.make(def.inputSchema);
-  const outputJson = def.outputSchema ? JSONSchema.make(def.outputSchema) : void 0;
-  const inputHoist = hoistDefinitions(inputJson);
-  const outputHoist = hoistDefinitions(outputJson);
-  const allDefs = {
-    ...inputHoist.defs,
-    ...outputHoist.defs
-  };
-  const registration = {
-    id,
-    pluginKey: "inMemoryTools",
-    sourceId: namespace,
-    name: def.name,
-    description: def.description,
-    inputSchema: inputHoist.stripped,
-    outputSchema: outputHoist.stripped,
-    mayElicit: isEffect
-  };
-  const entry = {
-    decode,
-    handler: def.handler,
-    isEffect
-  };
-  return { registration, entry, definitions: allDefs };
-};
-var makeInvoker = (handlers, pluginCtx) => ({
-  invoke: (toolId, args, options) => {
-    const entry = handlers.get(toolId);
-    if (!entry) {
-      return Effect7.fail(
-        new ToolInvocationError({
-          toolId,
-          message: `No handler registered for tool "${toolId}"`,
-          cause: void 0
-        })
-      );
-    }
-    const parsed = Effect7.try({
-      try: () => entry.decode(args),
-      catch: (err) => new ToolInvocationError({
-        toolId,
-        message: `Invalid input: ${err instanceof Error ? err.message : String(err)}`,
-        cause: err
-      })
-    });
-    if (!entry.isEffect) {
-      return parsed.pipe(
-        Effect7.flatMap(
-          (input) => Effect7.try({
-            try: () => new ToolInvocationResult({
-              data: entry.handler(input),
-              error: null
-            }),
-            catch: (err) => new ToolInvocationError({
-              toolId,
-              message: err instanceof Error ? err.message : String(err),
-              cause: err
-            })
-          })
-        )
-      );
-    }
-    const ctx = {
-      sdk: {
-        secrets: {
-          list: () => pluginCtx.secrets.list(pluginCtx.scope.id),
-          resolve: (secretId) => pluginCtx.secrets.resolve(secretId, pluginCtx.scope.id),
-          status: (secretId) => pluginCtx.secrets.status(secretId, pluginCtx.scope.id),
-          set: (input) => pluginCtx.secrets.set({
-            ...input,
-            scopeId: pluginCtx.scope.id
-          }),
-          remove: (secretId) => pluginCtx.secrets.remove(secretId)
-        }
-      },
-      elicit: (request) => Effect7.gen(function* () {
-        const raw = options?.onElicitation;
-        if (!raw) {
-          return yield* new ElicitationDeclinedError({
-            toolId,
-            action: "decline"
-          });
-        }
-        const handler = raw === "accept-all" ? () => Effect7.succeed(new ElicitationResponse({ action: "accept" })) : raw;
-        const response = yield* handler({
-          toolId,
-          args,
-          request
-        });
-        if (response.action !== "accept") {
-          return yield* new ElicitationDeclinedError({
-            toolId,
-            action: response.action
-          });
-        }
-        return response.content ?? {};
-      })
-    };
-    const effectHandler = entry.handler;
-    return parsed.pipe(
-      Effect7.flatMap((input) => effectHandler(input, ctx)),
-      Effect7.map((data) => new ToolInvocationResult({ data, error: null })),
-      Effect7.catchAll(
-        (err) => {
-          if (err != null && typeof err === "object" && "_tag" in err && err._tag === "ElicitationDeclinedError") {
-            return Effect7.fail(err);
-          }
-          return Effect7.fail(
-            new ToolInvocationError({
-              toolId,
-              message: err instanceof Error ? err.message : String(err),
-              cause: err
-            })
-          );
-        }
-      )
-    );
-  }
-});
-function tool(def) {
-  return def;
-}
-var inMemoryToolsPlugin = (config) => {
-  const ns = config.namespace ?? "memory";
-  return definePlugin({
-    key: "inMemoryTools",
-    init: (ctx) => Effect7.gen(function* () {
-      const handlers = /* @__PURE__ */ new Map();
-      const invoker = makeInvoker(handlers, ctx);
-      yield* ctx.tools.registerInvoker("inMemoryTools", invoker);
-      const results = config.tools.map((t) => buildRegistration(ns, t));
-      const allDefs = {};
-      for (const { definitions } of results) {
-        Object.assign(allDefs, definitions);
-      }
-      yield* ctx.tools.registerDefinitions(allDefs);
-      for (const { registration, entry } of results) {
-        handlers.set(registration.id, entry);
-      }
-      const registrations = results.map(({ registration }) => registration);
-      yield* ctx.tools.register(registrations);
-      return {
-        extension: {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Schema.Schema is invariant; `any` required to accept arbitrary MemoryToolDefinition types
-          addTools: (newTools) => Effect7.gen(function* () {
-            const newResults = newTools.map((t) => buildRegistration(ns, t));
-            const newDefs = {};
-            for (const { definitions } of newResults) {
-              Object.assign(newDefs, definitions);
-            }
-            yield* ctx.tools.registerDefinitions(newDefs);
-            for (const { registration, entry } of newResults) {
-              handlers.set(registration.id, entry);
-            }
-            const newRegistrations = newResults.map(({ registration }) => registration);
-            yield* ctx.tools.register(newRegistrations);
-          })
-        },
-        close: () => Effect7.gen(function* () {
-          yield* ctx.tools.unregister(registrations.map((r) => r.id));
-          for (const { registration } of results) {
-            handlers.delete(registration.id);
-          }
-        })
-      };
-    })
-  });
-};
-
-// src/schema-types.ts
-var VALID_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var REF_PATTERN2 = /^#\/(?:\$defs|definitions)\/(.+)$/;
-var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-var asStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-var truncate = (value, maxLength) => value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 4))} ...`;
-var formatPropertyKey = (value) => VALID_IDENTIFIER_PATTERN.test(value) ? value : JSON.stringify(value);
-var refNameFromPointer = (ref) => ref.match(REF_PATTERN2)?.[1];
-var refFallbackLabel = (ref) => refNameFromPointer(ref) ?? ref.split("/").at(-1) ?? ref;
-var summarizeLargeComposite = (schema, maxCompositeMembers) => {
-  for (const kind of ["oneOf", "anyOf"]) {
-    const items = schema[kind];
-    if (Array.isArray(items) && items.length > maxCompositeMembers) {
-      return { kind, count: items.length };
-    }
-  }
-  return null;
-};
-var primitiveTypeName = (value) => {
-  switch (value) {
-    case "integer":
-    case "number":
-      return "number";
-    case "string":
-    case "boolean":
-    case "null":
-      return value;
-    case "array":
-      return "unknown[]";
-    case "object":
-      return "Record<string, unknown>";
-    default:
-      return "unknown";
-  }
-};
-var renderComposite = (input) => {
-  const rawItems = input.schema[input.key];
-  const items = Array.isArray(rawItems) ? rawItems.map((item) => asRecord(item)) : [];
-  if (items.length === 0) {
-    return null;
-  }
-  const labels = items.map((item) => input.render(item, input.depthRemaining - 1)).filter((label) => label.length > 0);
-  if (labels.length === 0) {
-    return null;
-  }
-  return labels.join(input.key === "allOf" ? " & " : " | ");
-};
-var localDefinitionsFromSchema = (schema) => {
-  const root = asRecord(schema);
-  const defs = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(asRecord(root.$defs))) {
-    defs.set(key, value);
-  }
-  for (const [key, value] of Object.entries(asRecord(root.definitions))) {
-    defs.set(key, value);
-  }
-  return defs;
-};
-var schemaToTypeScriptPreview = (schema, options = {}) => {
-  const localDefs = localDefinitionsFromSchema(schema);
-  return schemaToTypeScriptPreviewWithDefs(schema, localDefs, options);
-};
-var schemaToTypeScriptPreviewWithDefs = (schema, defs, options = {}) => {
-  const maxLength = options.maxLength ?? 400;
-  const maxDepth = options.maxDepth ?? 6;
-  const maxProperties = options.maxProperties ?? 12;
-  const maxRefDepth = options.maxRefDepth ?? 3;
-  const maxCompositeMembers = options.maxCompositeMembers ?? 8;
-  const render = (input) => {
-    const current = asRecord(input.currentInput);
-    if (input.depthRemaining <= 0) {
-      if (typeof current.title === "string" && current.title.length > 0) {
-        return current.title;
-      }
-      if (current.type === "array") {
-        return "unknown[]";
-      }
-      if (current.type === "object" || current.properties) {
-        return "Record<string, unknown>";
-      }
-      return "unknown";
-    }
-    if (typeof current.$ref === "string") {
-      const refLabel = refFallbackLabel(current.$ref);
-      return input.refDepthRemaining > 0 ? refLabel : `unknown /* ${refLabel} omitted */`;
-    }
-    if ("const" in current) {
-      return JSON.stringify(current.const);
-    }
-    const enumValues = Array.isArray(current.enum) ? current.enum : [];
-    if (enumValues.length > 0) {
-      return truncate(enumValues.map((value) => JSON.stringify(value)).join(" | "), maxLength);
-    }
-    const largeComposite = summarizeLargeComposite(current, maxCompositeMembers);
-    if (largeComposite) {
-      return `unknown /* ${largeComposite.count}-way ${largeComposite.kind} omitted */`;
-    }
-    const renderNested = (value) => render({
-      currentInput: value,
-      depthRemaining: input.depthRemaining - 1,
-      refDepthRemaining: input.refDepthRemaining
-    });
-    const composite = renderComposite({
-      key: "oneOf",
-      schema: current,
-      render: (value) => renderNested(value),
-      depthRemaining: input.depthRemaining
-    }) ?? renderComposite({
-      key: "anyOf",
-      schema: current,
-      render: (value) => renderNested(value),
-      depthRemaining: input.depthRemaining
-    }) ?? renderComposite({
-      key: "allOf",
-      schema: current,
-      render: (value) => renderNested(value),
-      depthRemaining: input.depthRemaining
-    });
-    if (composite) {
-      return truncate(composite, maxLength);
-    }
-    if (current.nullable === true) {
-      const { nullable: _nullable, ...rest } = current;
-      return truncate(
-        `${render({
-          currentInput: rest,
-          depthRemaining: input.depthRemaining,
-          refDepthRemaining: input.refDepthRemaining
-        })} | null`,
-        maxLength
-      );
-    }
-    if (current.type === "array") {
-      const itemLabel = current.items ? render({
-        currentInput: current.items,
-        depthRemaining: input.depthRemaining - 1,
-        refDepthRemaining: input.refDepthRemaining
-      }) : "unknown";
-      return truncate(`${itemLabel}[]`, maxLength);
-    }
-    if (current.type === "object" || current.properties) {
-      const properties = asRecord(current.properties);
-      const propertyKeys = Object.keys(properties);
-      const required = new Set(asStringArray(current.required));
-      const additionalProperties = current.additionalProperties;
-      const additionalPropertiesLabel = additionalProperties && typeof additionalProperties === "object" ? render({
-        currentInput: additionalProperties,
-        depthRemaining: input.depthRemaining - 1,
-        refDepthRemaining: input.refDepthRemaining
-      }) : additionalProperties === true ? "unknown" : null;
-      if (propertyKeys.length === 0) {
-        if (additionalPropertiesLabel) {
-          return truncate(`Record<string, ${additionalPropertiesLabel}>`, maxLength);
-        }
-        return "Record<string, unknown>";
-      }
-      const visibleKeys = propertyKeys.slice(0, maxProperties);
-      const parts = visibleKeys.map(
-        (key) => `${formatPropertyKey(key)}${required.has(key) ? "" : "?"}: ${render({
-          currentInput: properties[key],
-          depthRemaining: input.depthRemaining - 1,
-          refDepthRemaining: input.refDepthRemaining
-        })}`
-      );
-      if (visibleKeys.length < propertyKeys.length) {
-        parts.push("...");
-      }
-      if (additionalPropertiesLabel) {
-        parts.push(`[key: string]: ${additionalPropertiesLabel}`);
-      }
-      return truncate(`{ ${parts.join("; ")} }`, maxLength);
-    }
-    if (Array.isArray(current.type)) {
-      return truncate(
-        current.type.filter((value) => typeof value === "string").map(primitiveTypeName).join(" | "),
-        maxLength
-      );
-    }
-    if (typeof current.type === "string") {
-      return primitiveTypeName(current.type);
-    }
-    return "unknown";
-  };
-  const referencedDepths = /* @__PURE__ */ new Map();
-  const collectPreviewRefs = (currentInput, refDepth) => {
-    const current = asRecord(currentInput);
-    if (summarizeLargeComposite(current, maxCompositeMembers)) {
-      return;
-    }
-    if (typeof current.$ref === "string") {
-      const name = refNameFromPointer(current.$ref);
-      if (!name) {
-        return;
-      }
-      const existingDepth = referencedDepths.get(name);
-      if (existingDepth !== void 0 && existingDepth <= refDepth) {
-        return;
-      }
-      referencedDepths.set(name, refDepth);
-      if (refDepth >= maxRefDepth) {
-        return;
-      }
-      const target = defs.get(name);
-      if (target !== void 0) {
-        collectPreviewRefs(target, refDepth + 1);
-      }
-      return;
-    }
-    for (const value of Object.values(current)) {
-      if (value && typeof value === "object") {
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            collectPreviewRefs(item, refDepth);
-          }
-        } else {
-          collectPreviewRefs(value, refDepth);
-        }
-      }
-    }
-  };
-  collectPreviewRefs(schema, 1);
-  const definitions = Object.fromEntries(
-    [...referencedDepths.entries()].sort(([left], [right]) => left.localeCompare(right)).flatMap(([name, refDepth]) => {
-      const target = defs.get(name);
-      if (target === void 0) {
-        return [];
-      }
-      return [
-        [
-          name,
-          render({
-            currentInput: target,
-            depthRemaining: maxDepth,
-            refDepthRemaining: Math.max(0, maxRefDepth - refDepth)
-          })
-        ]
-      ];
-    })
-  );
-  return {
-    type: render({
-      currentInput: schema,
-      depthRemaining: maxDepth,
-      refDepthRemaining: maxRefDepth
-    }),
-    definitions
-  };
-};
-var buildToolTypeScriptPreview = (input) => {
-  const inputPreview = input.inputSchema !== void 0 ? schemaToTypeScriptPreviewWithDefs(input.inputSchema, input.defs, input.options) : null;
-  const outputPreview = input.outputSchema !== void 0 ? schemaToTypeScriptPreviewWithDefs(input.outputSchema, input.defs, input.options) : null;
-  const mergedDefinitions = {
-    ...inputPreview?.definitions,
-    ...outputPreview?.definitions
-  };
-  return {
-    ...inputPreview ? { inputTypeScript: inputPreview.type } : {},
-    ...outputPreview ? { outputTypeScript: outputPreview.type } : {},
-    ...Object.keys(mergedDefinitions).length > 0 ? { typeScriptDefinitions: mergedDefinitions } : {}
-  };
-};
-
-// src/runtime-tools.ts
-import { Effect as Effect8, JSONSchema as JSONSchema2, Schema as Schema10 } from "effect";
-var runtimeTool = (def) => def;
-var buildRuntimeTool = (pluginKey, sourceId, def) => {
-  const inputJson = JSONSchema2.make(def.inputSchema);
-  const outputJson = def.outputSchema ? JSONSchema2.make(def.outputSchema) : void 0;
-  const inputHoist = hoistDefinitions(inputJson);
-  const outputHoist = hoistDefinitions(outputJson);
-  return {
-    registration: {
-      id: ToolId.make(def.id),
-      pluginKey,
-      sourceId,
-      name: def.name,
-      description: def.description,
-      inputSchema: inputHoist.stripped,
-      outputSchema: outputHoist.stripped
-    },
-    definitions: {
-      ...inputHoist.defs,
-      ...outputHoist.defs
-    },
-    entry: {
-      decode: Schema10.decodeUnknownSync(def.inputSchema),
-      handler: def.handler
-    }
-  };
-};
-var toRuntimeHandler = (toolId, entry) => ({
-  invoke: (args) => Effect8.try({
-    try: () => entry.decode(args),
-    catch: (err) => new ToolInvocationError({
-      toolId,
-      message: `Invalid input: ${err instanceof Error ? err.message : String(err)}`,
-      cause: err
-    })
-  }).pipe(
-    Effect8.flatMap((input) => entry.handler(input)),
-    Effect8.map((data) => new ToolInvocationResult({ data, error: null })),
-    Effect8.mapError(
-      (err) => err instanceof ToolInvocationError ? err : new ToolInvocationError({
-        toolId,
-        message: err instanceof Error ? err.message : String(err),
-        cause: err
-      })
-    )
-  )
-});
-var registerRuntimeTools = (input) => Effect8.gen(function* () {
-  const built = yield* Effect8.forEach(
-    input.tools,
-    (tool2) => Effect8.sync(() => {
-      const sourceId = tool2.sourceId ?? input.source?.id;
-      if (!sourceId) {
-        throw new Error(
-          `Runtime tool "${tool2.id}" is missing a sourceId and no shared runtime source was provided`
-        );
-      }
-      return buildRuntimeTool(input.pluginKey, sourceId, tool2);
-    })
-  );
-  if (input.source && input.sources) {
-    yield* input.sources.registerRuntime(
-      new Source({
-        id: input.source.id,
-        name: input.source.name,
-        kind: input.source.kind ?? input.pluginKey,
-        runtime: true,
-        canRemove: input.source.canRemove ?? false,
-        canRefresh: input.source.canRefresh ?? false
-      })
-    );
-  }
-  const defs = {};
-  for (const tool2 of built) {
-    Object.assign(defs, tool2.definitions);
-    yield* input.registry.registerRuntimeHandler(
-      tool2.registration.id,
-      toRuntimeHandler(tool2.registration.id, tool2.entry)
-    );
-  }
-  yield* input.registry.registerRuntimeDefinitions(defs);
-  yield* input.registry.registerRuntime(built.map((tool2) => tool2.registration));
-  const toolIds = built.map((tool2) => tool2.registration.id);
-  const defNames = Object.keys(defs);
-  return {
-    toolIds,
-    close: () => Effect8.gen(function* () {
-      yield* input.registry.unregisterRuntime(toolIds);
-      yield* input.registry.unregisterRuntimeDefinitions(defNames);
-      if (input.source && input.sources) {
-        yield* input.sources.unregisterRuntime(input.source.id);
-      }
-    })
-  };
-});
-
-// src/in-memory/tool-registry.ts
-import { Effect as Effect9 } from "effect";
-var makeInMemoryToolRegistry = () => {
-  const tools = /* @__PURE__ */ new Map();
-  const runtimeTools = /* @__PURE__ */ new Map();
-  const runtimeHandlers = /* @__PURE__ */ new Map();
-  const invokers = /* @__PURE__ */ new Map();
-  const sharedDefs = /* @__PURE__ */ new Map();
-  const runtimeDefs = /* @__PURE__ */ new Map();
-  const getTool = (toolId) => runtimeTools.get(toolId) ?? tools.get(toolId);
-  const getDefs = () => {
-    const defs = /* @__PURE__ */ new Map();
-    for (const [k, v] of sharedDefs) defs.set(k, v);
-    for (const [k, v] of runtimeDefs) defs.set(k, v);
-    return defs;
-  };
-  return {
-    list: (filter) => Effect9.sync(() => {
-      const byId = /* @__PURE__ */ new Map();
-      for (const tool2 of tools.values()) byId.set(tool2.id, tool2);
-      for (const tool2 of runtimeTools.values()) byId.set(tool2.id, tool2);
-      let result = [...byId.values()];
-      if (filter?.sourceId) {
-        const sid = filter.sourceId;
-        result = result.filter((t) => t.sourceId === sid);
-      }
-      if (filter?.query) {
-        const q = filter.query.toLowerCase();
-        result = result.filter(
-          (t) => t.name.toLowerCase().includes(q) || t.description?.toLowerCase().includes(q)
-        );
-      }
-      return result.map((t) => ({
-        id: t.id,
-        pluginKey: t.pluginKey,
-        sourceId: t.sourceId,
-        name: t.name,
-        description: t.description
-      }));
-    }),
-    schema: (toolId) => Effect9.fromNullable(getTool(toolId)).pipe(
-      Effect9.mapError(() => new ToolNotFoundError({ toolId })),
-      Effect9.map((t) => {
-        const defs = getDefs();
-        const typeScriptPreview = buildToolTypeScriptPreview({
-          inputSchema: t.inputSchema,
-          outputSchema: t.outputSchema,
-          defs,
-          options: {
-            maxLength: Infinity,
-            maxProperties: Infinity,
-            maxCompositeMembers: Infinity,
-            maxRefDepth: 20
-          }
-        });
-        return {
-          id: t.id,
-          ...typeScriptPreview,
-          inputSchema: t.inputSchema ? reattachDefs(t.inputSchema, defs) : void 0,
-          outputSchema: t.outputSchema ? reattachDefs(t.outputSchema, defs) : void 0
-        };
-      })
-    ),
-    definitions: () => Effect9.sync(() => {
-      const result = {};
-      for (const [k, v] of sharedDefs) {
-        result[k] = v;
-      }
-      for (const [k, v] of runtimeDefs) {
-        result[k] = v;
-      }
-      return result;
-    }),
-    registerDefinitions: (defs) => Effect9.sync(() => {
-      for (const [k, v] of Object.entries(defs)) {
-        sharedDefs.set(k, normalizeRefs(v));
-      }
-    }),
-    registerRuntimeDefinitions: (defs) => Effect9.sync(() => {
-      for (const [k, v] of Object.entries(defs)) {
-        runtimeDefs.set(k, normalizeRefs(v));
-      }
-    }),
-    unregisterRuntimeDefinitions: (names) => Effect9.sync(() => {
-      for (const name of names) {
-        runtimeDefs.delete(name);
-      }
-    }),
-    registerInvoker: (pluginKey, invoker) => Effect9.sync(() => {
-      invokers.set(pluginKey, invoker);
-    }),
-    resolveAnnotations: (toolId) => Effect9.gen(function* () {
-      const tool2 = getTool(toolId);
-      if (!tool2) return void 0;
-      const runtimeHandler = runtimeHandlers.get(toolId);
-      if (runtimeHandler?.resolveAnnotations) {
-        return yield* runtimeHandler.resolveAnnotations();
-      }
-      const invoker = invokers.get(tool2.pluginKey);
-      if (!invoker?.resolveAnnotations) return void 0;
-      return yield* invoker.resolveAnnotations(toolId);
-    }),
-    invoke: (toolId, args, options) => Effect9.gen(function* () {
-      const tool2 = yield* Effect9.fromNullable(getTool(toolId)).pipe(
-        Effect9.mapError(() => new ToolNotFoundError({ toolId }))
-      );
-      const runtimeHandler = runtimeHandlers.get(toolId);
-      if (runtimeHandler) {
-        return yield* runtimeHandler.invoke(args, options);
-      }
-      const invoker = invokers.get(tool2.pluginKey);
-      if (!invoker) {
-        return yield* new ToolInvocationError({
-          toolId,
-          message: `No invoker registered for plugin "${tool2.pluginKey}"`,
-          cause: void 0
-        });
-      }
-      return yield* invoker.invoke(toolId, args, options);
-    }),
-    register: (newTools) => Effect9.sync(() => {
-      for (const t of newTools) {
-        tools.set(t.id, {
-          ...t,
-          inputSchema: normalizeRefs(t.inputSchema),
-          outputSchema: normalizeRefs(t.outputSchema)
-        });
-      }
-    }),
-    registerRuntime: (newTools) => Effect9.sync(() => {
-      for (const t of newTools) {
-        runtimeTools.set(t.id, {
-          ...t,
-          inputSchema: normalizeRefs(t.inputSchema),
-          outputSchema: normalizeRefs(t.outputSchema)
-        });
-      }
-    }),
-    registerRuntimeHandler: (toolId, handler) => Effect9.sync(() => {
-      runtimeHandlers.set(toolId, handler);
-    }),
-    unregisterRuntime: (toolIds) => Effect9.sync(() => {
-      for (const id of toolIds) {
-        runtimeTools.delete(id);
-        runtimeHandlers.delete(id);
-      }
-    }),
-    unregister: (toolIds) => Effect9.sync(() => {
-      for (const id of toolIds) {
-        tools.delete(id);
-        runtimeTools.delete(id);
-        runtimeHandlers.delete(id);
-      }
-    }),
-    unregisterBySource: (sourceId) => Effect9.sync(() => {
-      for (const [id, t] of tools) {
-        if (t.sourceId === sourceId) {
-          tools.delete(id);
-        }
-      }
-      for (const [id, t] of runtimeTools) {
-        if (t.sourceId === sourceId) {
-          runtimeTools.delete(id);
-          runtimeHandlers.delete(id);
-        }
-      }
-    })
-  };
-};
-
-// src/in-memory/secret-store.ts
-import { Effect as Effect10, Option } from "effect";
-var makeInMemorySecretProvider = () => {
-  const values = /* @__PURE__ */ new Map();
-  return {
-    key: "memory",
-    writable: true,
-    get: (key) => Effect10.sync(() => values.get(key) ?? null),
-    set: (key, value) => Effect10.sync(() => {
-      values.set(key, value);
-    }),
-    delete: (key) => Effect10.sync(() => values.delete(key)),
-    list: () => Effect10.sync(() => [...values.keys()].map((k) => ({ id: k, name: k })))
-  };
-};
-var makeInMemorySecretStore = () => {
-  const refs = /* @__PURE__ */ new Map();
-  const providers = [];
-  const defaultProvider = makeInMemorySecretProvider();
-  providers.push(defaultProvider);
-  const findWritableProvider = (key) => key ? providers.find((p) => p.key === key) : providers.find((p) => p.writable);
-  const resolveFromProviders = (secretId, providerKey) => {
-    if (providerKey) {
-      const provider = providers.find((p) => p.key === providerKey);
-      return provider ? provider.get(secretId) : Effect10.succeed(null);
-    }
-    return Effect10.gen(function* () {
-      for (const provider of providers) {
-        const value = yield* provider.get(secretId);
-        if (value !== null) return value;
-      }
-      return null;
-    });
-  };
-  return {
-    list: (scopeId) => Effect10.sync(() => [...refs.values()].filter((r) => r.scopeId === scopeId)),
-    get: (secretId) => Effect10.fromNullable(refs.get(secretId)).pipe(
-      Effect10.mapError(() => new SecretNotFoundError({ secretId }))
-    ),
-    resolve: (secretId, _scopeId) => Effect10.gen(function* () {
-      const ref = refs.get(secretId);
-      const providerKey = ref ? Option.getOrUndefined(ref.provider) : void 0;
-      const value = yield* resolveFromProviders(secretId, providerKey);
-      if (value === null) {
-        return yield* new SecretResolutionError({
-          secretId,
-          message: `Secret "${secretId}" not found in any provider`
-        });
-      }
-      return value;
-    }),
-    status: (secretId, _scopeId) => Effect10.gen(function* () {
-      const value = yield* resolveFromProviders(secretId, void 0);
-      return value !== null ? "resolved" : "missing";
-    }),
-    set: (input) => Effect10.gen(function* () {
-      const provider = findWritableProvider(input.provider);
-      if (!provider?.set) {
-        return yield* new SecretResolutionError({
-          secretId: input.id,
-          message: `No writable provider found${input.provider ? ` (requested: ${input.provider})` : ""}`
-        });
-      }
-      yield* provider.set(input.id, input.value);
-      const ref = {
-        id: input.id,
-        scopeId: input.scopeId,
-        name: input.name,
-        provider: Option.fromNullable(input.provider),
-        purpose: input.purpose,
-        createdAt: /* @__PURE__ */ new Date()
-      };
-      refs.set(input.id, ref);
-      return ref;
-    }),
-    remove: (secretId) => Effect10.gen(function* () {
-      const ref = refs.get(secretId);
-      if (!ref) return yield* new SecretNotFoundError({ secretId });
-      const providerKey = Option.getOrUndefined(ref.provider);
-      const provider = findWritableProvider(providerKey);
-      if (provider?.delete) {
-        yield* provider.delete(secretId);
-      }
-      refs.delete(secretId);
-      return true;
-    }),
-    addProvider: (provider) => Effect10.sync(() => {
-      providers.push(provider);
-    }),
-    providers: () => Effect10.sync(() => providers.map((p) => p.key))
-  };
-};
-
-// src/in-memory/policy-engine.ts
-import { Effect as Effect11 } from "effect";
-var makeInMemoryPolicyEngine = () => {
-  const policies = /* @__PURE__ */ new Map();
-  let counter = 0;
-  return {
-    list: (scopeId) => Effect11.succeed([...policies.values()].filter((p) => p.scopeId === scopeId)),
-    check: (_input) => Effect11.void,
-    add: (policy) => Effect11.sync(() => {
-      const id = PolicyId.make(`policy-${++counter}`);
-      const full = { ...policy, id, createdAt: /* @__PURE__ */ new Date() };
-      policies.set(id, full);
-      return full;
-    }),
-    remove: (policyId) => Effect11.succeed(policies.delete(policyId))
-  };
-};
-
-// src/testing.ts
-var makeTestConfig = (options) => {
-  const cwd = options?.cwd ?? "/test";
-  const scope = {
-    id: ScopeId.make("test-scope"),
-    name: cwd,
-    createdAt: /* @__PURE__ */ new Date()
-  };
-  return {
-    scope,
-    tools: makeInMemoryToolRegistry(),
-    sources: makeInMemorySourceRegistry(),
-    secrets: makeInMemorySecretStore(),
-    policies: makeInMemoryPolicyEngine(),
-    plugins: options?.plugins
-  };
-};
-
-// src/plugin-kv.ts
-import { Effect as Effect12 } from "effect";
-var scopeKv = (kv, namespace) => ({
-  get: (key) => kv.get(namespace, key),
-  set: (entries) => kv.set(namespace, entries),
-  delete: (keys) => kv.delete(namespace, keys),
-  list: () => kv.list(namespace),
-  deleteAll: () => kv.deleteAll(namespace),
-  withTransaction: kv.withTransaction
-});
-var makeInMemoryScopedKv = () => {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    get: (key) => Effect12.succeed(store.get(key) ?? null),
-    set: (entries) => Effect12.sync(() => {
-      for (const { key, value } of entries) store.set(key, value);
-    }),
-    delete: (keys) => Effect12.sync(() => {
-      let count = 0;
-      for (const key of keys) if (store.delete(key)) count++;
-      return count;
-    }),
-    list: () => Effect12.sync(() => [...store.entries()].map(([key, value]) => ({ key, value }))),
-    deleteAll: () => Effect12.sync(() => {
-      const n = store.size;
-      store.clear();
-      return n;
-    }),
-    withTransaction: (effect) => effect
-  };
-};
-
-export {
-  ScopeId,
-  ToolId,
-  SecretId,
-  PolicyId,
-  ToolNotFoundError,
-  ToolInvocationError,
-  SecretNotFoundError,
-  SecretResolutionError,
-  PolicyDeniedError,
-  ToolAnnotations,
-  ToolMetadata,
-  ToolSchema,
-  ToolInvocationResult,
-  ToolListFilter,
-  ToolRegistry,
-  ToolRegistration,
-  Source,
-  SourceDetectionResult,
-  SourceRegistry,
-  makeInMemorySourceRegistry,
-  FormElicitation,
-  UrlElicitation,
-  ElicitationAction,
-  ElicitationResponse,
-  ElicitationDeclinedError,
-  SecretRef,
-  SetSecretInput,
-  SecretStore,
-  PolicyAction,
-  Policy,
-  PolicyCheckInput,
-  PolicyEngine,
-  Scope,
-  definePlugin,
-  createExecutor,
-  normalizeRefs,
-  hoistDefinitions,
-  collectRefs,
-  reattachDefs,
-  tool,
-  inMemoryToolsPlugin,
-  schemaToTypeScriptPreview,
-  schemaToTypeScriptPreviewWithDefs,
-  buildToolTypeScriptPreview,
-  runtimeTool,
-  registerRuntimeTools,
-  makeInMemoryToolRegistry,
-  makeInMemorySecretProvider,
-  makeInMemorySecretStore,
-  makeInMemoryPolicyEngine,
-  makeTestConfig,
-  scopeKv,
-  makeInMemoryScopedKv
-};
-//# sourceMappingURL=chunk-D7CT3UMO.js.map