@executor-js/sdk 0.1.0 → 0.2.0

package/dist/chunk-2WV7VSNL.js

@@ -1,4440 +0,0 @@
-// src/blob.ts
-import { Effect } from "effect";
-import { StorageError } from "@executor-js/storage-core";
-var assertScope = (scope, scopes) => scopes.includes(scope) ? Effect.void : Effect.fail(
-  new StorageError({
-    message: `Blob write targets scope "${scope}" which is not in the executor's scope stack [${scopes.join(", ")}].`,
-    cause: void 0
-  })
-);
-var nsFor = (scope, pluginId) => `${scope}/${pluginId}`;
-var pluginBlobStore = (store, scopes, pluginId) => ({
-  get: (key) => Effect.gen(function* () {
-    const namespaces = scopes.map((s) => nsFor(s, pluginId));
-    const hits = yield* store.getMany(namespaces, key);
-    if (hits.size === 0) return null;
-    for (const ns of namespaces) {
-      const v = hits.get(ns);
-      if (v !== void 0) return v;
-    }
-    return null;
-  }),
-  put: (key, value, options) => Effect.flatMap(
-    assertScope(options.scope, scopes),
-    () => store.put(nsFor(options.scope, pluginId), key, value)
-  ),
-  delete: (key, options) => Effect.flatMap(
-    assertScope(options.scope, scopes),
-    () => store.delete(nsFor(options.scope, pluginId), key)
-  ),
-  has: (key) => store.getMany(
-    scopes.map((s) => nsFor(s, pluginId)),
-    key
-  ).pipe(Effect.map((hits) => hits.size > 0))
-});
-var makeInMemoryBlobStore = () => {
-  const store = /* @__PURE__ */ new Map();
-  const k = (ns, key) => `${ns}::${key}`;
-  return {
-    get: (ns, key) => Effect.sync(() => store.get(k(ns, key)) ?? null),
-    getMany: (namespaces, key) => Effect.sync(() => {
-      const hits = /* @__PURE__ */ new Map();
-      for (const ns of namespaces) {
-        const v = store.get(k(ns, key));
-        if (v !== void 0) hits.set(ns, v);
-      }
-      return hits;
-    }),
-    put: (ns, key, value) => Effect.sync(() => {
-      store.set(k(ns, key), value);
-    }),
-    delete: (ns, key) => Effect.sync(() => {
-      store.delete(k(ns, key));
-    }),
-    has: (ns, key) => Effect.sync(() => store.has(k(ns, key)))
-  };
-};
-
-// 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"));
-var ConnectionId = Schema.String.pipe(Schema.brand("ConnectionId"));
-
-// src/connections.ts
-import { Data, Schema as Schema2 } from "effect";
-var ConnectionProviderState = Schema2.Record(Schema2.String, Schema2.Unknown);
-var ConnectionRef = class extends Schema2.Class("ConnectionRef")({
-  id: ConnectionId,
-  scopeId: ScopeId,
-  provider: Schema2.String,
-  identityLabel: Schema2.NullOr(Schema2.String),
-  accessTokenSecretId: SecretId,
-  refreshTokenSecretId: Schema2.NullOr(SecretId),
-  /** Epoch ms when the access token expires; null if not declared. */
-  expiresAt: Schema2.NullOr(Schema2.Number),
-  /** OAuth-style scope string as returned by the token endpoint. Named
-   *  `oauthScope` to avoid collision with the executor scope id. */
-  oauthScope: Schema2.NullOr(Schema2.String),
-  providerState: Schema2.NullOr(ConnectionProviderState),
-  createdAt: Schema2.Date,
-  updatedAt: Schema2.Date
-}) {
-};
-var TokenMaterial = class extends Schema2.Class("TokenMaterial")({
-  /** Target secret id. Plugins typically derive this from the source id
-   *  + a stable suffix (e.g. `${sourceId}.access_token`). */
-  secretId: SecretId,
-  /** Display name stamped on the secret row. Only visible to code — the
-   *  Connections UI hides connection-owned secrets. */
-  name: Schema2.String,
-  value: Schema2.String
-}) {
-};
-var CreateConnectionInput = class extends Schema2.Class(
-  "CreateConnectionInput"
-)({
-  id: ConnectionId,
-  /** Executor scope id that will own this connection + its backing
-   *  secrets. This is the sharing boundary: a user scope is personal,
-   *  an org/workspace scope is shared with descendants. */
-  scope: ScopeId,
-  provider: Schema2.String,
-  identityLabel: Schema2.NullOr(Schema2.String),
-  accessToken: TokenMaterial,
-  refreshToken: Schema2.NullOr(TokenMaterial),
-  expiresAt: Schema2.NullOr(Schema2.Number),
-  /** OAuth-style scope string. Distinct from the executor scope above. */
-  oauthScope: Schema2.NullOr(Schema2.String),
-  providerState: Schema2.NullOr(ConnectionProviderState)
-}) {
-};
-var ConnectionRefreshError = class extends Data.TaggedError(
-  "ConnectionRefreshError"
-) {
-};
-var UpdateConnectionTokensInput = class extends Schema2.Class(
-  "UpdateConnectionTokensInput"
-)({
-  id: ConnectionId,
-  accessToken: Schema2.String,
-  refreshToken: Schema2.optional(Schema2.NullOr(Schema2.String)),
-  expiresAt: Schema2.optional(Schema2.NullOr(Schema2.Number)),
-  oauthScope: Schema2.optional(Schema2.NullOr(Schema2.String)),
-  providerState: Schema2.optional(Schema2.NullOr(ConnectionProviderState)),
-  identityLabel: Schema2.optional(Schema2.NullOr(Schema2.String))
-}) {
-};
-
-// src/core-schema.ts
-var coreSchema = {
-  source: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      plugin_id: { type: "string", required: true, index: true },
-      kind: { type: "string", required: true },
-      name: { type: "string", required: true },
-      url: { type: "string", required: false },
-      can_remove: {
-        type: "boolean",
-        required: true,
-        defaultValue: true
-      },
-      can_refresh: {
-        type: "boolean",
-        required: true,
-        defaultValue: false
-      },
-      can_edit: {
-        type: "boolean",
-        required: true,
-        defaultValue: false
-      },
-      created_at: { type: "date", required: true },
-      updated_at: { type: "date", required: true }
-    }
-  },
-  tool: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      source_id: { type: "string", required: true, index: true },
-      plugin_id: { type: "string", required: true, index: true },
-      name: { type: "string", required: true },
-      description: { type: "string", required: true },
-      input_schema: { type: "json", required: false },
-      output_schema: { type: "json", required: false },
-      // NOTE: tool annotations (requiresApproval, approvalDescription,
-      // mayElicit) are NOT stored on this row. They're derived at read
-      // time from plugin-owned data via `plugin.resolveAnnotations`,
-      // because the source of truth already lives in each plugin's own
-      // storage (openapi's OperationBinding, etc.) and duplicating it
-      // here would just mean bulk-rewriting rows every time the
-      // derivation logic changes.
-      created_at: { type: "date", required: true },
-      updated_at: { type: "date", required: true }
-    }
-  },
-  // Shared JSON-schema `$defs` stored once per source. Tool input/output
-  // schemas carry `$ref: "#/$defs/X"` pointers; the read path attaches
-  // matching defs under `$defs` before returning. Keyed by synthetic id
-  // `${source_id}.${name}` so cleanup on source removal is a single
-  // deleteMany by source_id.
-  definition: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      source_id: { type: "string", required: true, index: true },
-      plugin_id: { type: "string", required: true, index: true },
-      name: { type: "string", required: true },
-      schema: { type: "json", required: true },
-      created_at: { type: "date", required: true }
-    }
-  },
-  // Secrets live in the core surface as metadata (id, display name,
-  // provider key). Actual values never touch this table — they live in
-  // the secret provider (keychain, 1password, file, etc.) and are
-  // resolved on demand via `ctx.secrets.get(id)`.
-  //
-  // `owned_by_connection_id` ties the row to a connection. Connection-
-  // owned secrets are plumbing, not user-facing values: `ctx.secrets.list`
-  // filters them out (the user sees the Connection instead), and
-  // `ctx.secrets.remove` refuses to delete them (Connection.remove is
-  // the single owner of the lifecycle). The FK is nullable so existing
-  // "bare" secrets (API keys entered by the user, pre-connection OAuth
-  // rows during migration) remain visible and removable unchanged.
-  secret: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      name: { type: "string", required: true },
-      provider: { type: "string", required: true, index: true },
-      owned_by_connection_id: {
-        type: "string",
-        required: false,
-        index: true
-      },
-      created_at: { type: "date", required: true }
-    }
-  },
-  // Connections — sign-in state for one identity against one remote
-  // provider. A Connection owns one or more `secret` rows (access +
-  // refresh tokens, etc.) via `secret.owned_by_connection_id`, and the
-  // SDK exposes `ctx.connections.accessToken(id)` which transparently
-  // refreshes the backing secrets when they're near expiry. Plugins
-  // contribute refresh behavior via `plugin.connectionProviders[].refresh`
-  // keyed by `provider`, same pattern as `secretProviders`.
-  //
-  // `provider_state` is plugin-owned opaque JSON — token endpoint URL,
-  // scopes, issuer, auth-server metadata — whatever the provider's
-  // refresh handler needs to re-hit the token endpoint. It's NOT
-  // sensitive (all secrets go through the provider-backed secret rows);
-  // it's just enough metadata to drive a refresh without re-running
-  // discovery.
-  connection: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      /** Routing key into `plugin.connectionProviders`. Typical shape
-       *  is `${pluginId}:${kind}` (e.g. `openapi:oauth2`, `mcp:oauth2`,
-       *  `google-discovery:google`). Mirrors `secret.provider`. */
-      provider: { type: "string", required: true, index: true },
-      /** Display label shown in the Connections UI. Usually the account
-       *  email / handle / org name the user signed in as. */
-      identity_label: { type: "string", required: false },
-      /** Stable id of the access-token secret. Always present. */
-      access_token_secret_id: { type: "string", required: true },
-      /** Stable id of the refresh-token secret. Null for flows that
-       *  don't mint a refresh token (client_credentials, etc.). */
-      refresh_token_secret_id: { type: "string", required: false },
-      /** Epoch ms when the access token expires. Null if the provider
-       *  didn't declare an expiry. Used as the refresh trigger. Stored as
-       *  `bigint` because `Date.now()` overflows int32. */
-      expires_at: { type: "number", required: false, bigint: true },
-      /** Scope string as returned by the token endpoint. */
-      scope: { type: "string", required: false },
-      /** Opaque plugin-owned JSON — token endpoint URL, scopes list,
-       *  discovery hints, etc. Never sensitive. */
-      provider_state: { type: "json", required: false },
-      created_at: { type: "date", required: true },
-      updated_at: { type: "date", required: true }
-    }
-  },
-  // Pending OAuth authorization rows shared by every OAuth-capable plugin.
-  // Rows are short-lived and deleted after completion/cancel; the resulting
-  // `connection` row is the durable sign-in state.
-  oauth2_session: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      plugin_id: { type: "string", required: true, index: true },
-      strategy: { type: "string", required: true },
-      connection_id: { type: "string", required: true, index: true },
-      token_scope: { type: "string", required: true },
-      redirect_url: { type: "string", required: true },
-      payload: { type: "json", required: true },
-      expires_at: { type: "number", required: true, bigint: true },
-      created_at: { type: "date", required: true }
-    }
-  },
-  // User-authored overrides for tool permissions. Each row is one rule:
-  // a glob-ish pattern + an action (approve / require_approval / block).
-  // Resolution walks the scope stack innermost-first, then `position`
-  // ascending within each scope; first match wins. Plugin-derived
-  // annotations from `resolveAnnotations` apply only when no rule
-  // matches.
-  //
-  // Pattern grammar (v1):
-  //   - `*`                  every tool id (universal)
-  //   - `vercel.dns.create`  exact tool id
-  //   - `vercel.dns.*`       any tool whose id starts with `vercel.dns.`
-  //   - `vercel.*`           plugin-wide
-  // No `**`, no brace expansion, no leading-`*` prefixes (`*foo`, `*.foo`).
-  tool_policy: {
-    fields: {
-      id: { type: "string", required: true },
-      scope_id: { type: "string", required: true, index: true },
-      pattern: { type: "string", required: true },
-      /** "approve" | "require_approval" | "block". */
-      action: { type: "string", required: true },
-      /** Fractional-indexing key (Jira lexorank style). Lower lex order =
-       *  higher precedence. New rules default to a key generated above
-       *  the current minimum. Strings instead of numbers so we can
-       *  always lengthen the key to insert between two adjacent rows
-       *  without precision loss; see `fractional-indexing` in
-       *  `policies.ts`. */
-      position: { type: "string", required: true, index: true },
-      created_at: { type: "date", required: true },
-      updated_at: { type: "date", required: true }
-    }
-  }
-};
-var TOOL_POLICY_ACTIONS = [
-  "approve",
-  "require_approval",
-  "block"
-];
-var isToolPolicyAction = (value) => typeof value === "string" && TOOL_POLICY_ACTIONS.includes(value);
-
-// src/elicitation.ts
-import { Schema as Schema3 } from "effect";
-var FormElicitation = class extends Schema3.TaggedClass()("FormElicitation", {
-  message: Schema3.String,
-  /** JSON Schema describing the fields to collect */
-  requestedSchema: Schema3.Record(Schema3.String, Schema3.Unknown)
-}) {
-};
-var UrlElicitation = class extends Schema3.TaggedClass()("UrlElicitation", {
-  message: Schema3.String,
-  url: Schema3.String,
-  /** Unique ID so the host can correlate the callback */
-  elicitationId: Schema3.String
-}) {
-};
-var ElicitationAction = Schema3.Literals(["accept", "decline", "cancel"]);
-var ElicitationResponse = class extends Schema3.Class("ElicitationResponse")({
-  action: ElicitationAction,
-  /** Present when action is "accept" — the data the user provided */
-  content: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Unknown))
-}) {
-};
-var ElicitationDeclinedError = class extends Schema3.TaggedErrorClass()(
-  "ElicitationDeclinedError",
-  {
-    toolId: ToolId,
-    action: Schema3.Literals(["decline", "cancel"])
-  }
-) {
-};
-
-// src/errors.ts
-import { Data as Data2, Schema as Schema4 } from "effect";
-var ToolNotFoundError = class extends Schema4.TaggedErrorClass()(
-  "ToolNotFoundError",
-  { toolId: ToolId }
-) {
-};
-var ToolInvocationError = class extends Data2.TaggedError("ToolInvocationError") {
-};
-var PluginNotLoadedError = class extends Schema4.TaggedErrorClass()(
-  "PluginNotLoadedError",
-  {
-    pluginId: Schema4.String,
-    toolId: ToolId
-  }
-) {
-};
-var NoHandlerError = class extends Schema4.TaggedErrorClass()(
-  "NoHandlerError",
-  {
-    toolId: ToolId,
-    pluginId: Schema4.String
-  }
-) {
-};
-var ToolBlockedError = class extends Schema4.TaggedErrorClass()(
-  "ToolBlockedError",
-  {
-    toolId: ToolId,
-    pattern: Schema4.String
-  }
-) {
-};
-var SourceNotFoundError = class extends Schema4.TaggedErrorClass()(
-  "SourceNotFoundError",
-  { sourceId: Schema4.String }
-) {
-};
-var SourceRemovalNotAllowedError = class extends Schema4.TaggedErrorClass()(
-  "SourceRemovalNotAllowedError",
-  { sourceId: Schema4.String }
-) {
-};
-var SecretNotFoundError = class extends Schema4.TaggedErrorClass()(
-  "SecretNotFoundError",
-  { secretId: SecretId }
-) {
-};
-var SecretResolutionError = class extends Schema4.TaggedErrorClass()(
-  "SecretResolutionError",
-  {
-    secretId: SecretId,
-    message: Schema4.String
-  }
-) {
-};
-var SecretOwnedByConnectionError = class extends Schema4.TaggedErrorClass()(
-  "SecretOwnedByConnectionError",
-  {
-    secretId: SecretId,
-    connectionId: ConnectionId
-  }
-) {
-};
-var ConnectionNotFoundError = class extends Schema4.TaggedErrorClass()(
-  "ConnectionNotFoundError",
-  { connectionId: ConnectionId }
-) {
-};
-var ConnectionProviderNotRegisteredError = class extends Schema4.TaggedErrorClass()(
-  "ConnectionProviderNotRegisteredError",
-  {
-    provider: Schema4.String,
-    connectionId: Schema4.optional(ConnectionId)
-  }
-) {
-};
-var ConnectionRefreshNotSupportedError = class extends Schema4.TaggedErrorClass()(
-  "ConnectionRefreshNotSupportedError",
-  {
-    connectionId: ConnectionId,
-    provider: Schema4.String
-  }
-) {
-};
-var ConnectionReauthRequiredError = class extends Schema4.TaggedErrorClass()(
-  "ConnectionReauthRequiredError",
-  {
-    connectionId: ConnectionId,
-    provider: Schema4.String,
-    message: Schema4.String
-  }
-) {
-};
-
-// src/secrets.ts
-import { Schema as Schema5 } from "effect";
-var SecretRef = class extends Schema5.Class("SecretRef")({
-  id: SecretId,
-  scopeId: ScopeId,
-  /** Human-readable label (e.g. "Cloudflare API Token") */
-  name: Schema5.String,
-  /** Which provider holds the value */
-  provider: Schema5.String,
-  createdAt: Schema5.Date
-}) {
-};
-var SetSecretInput = class extends Schema5.Class(
-  "SetSecretInput"
-)({
-  id: SecretId,
-  /** Scope id to own this secret. Must be one of the executor's
-   *  configured scopes. */
-  scope: ScopeId,
-  /** Display name shown in secret-list UI. */
-  name: Schema5.String,
-  /** The secret value itself — never persisted outside the provider. */
-  value: Schema5.String,
-  /** Optional provider routing. If unset the executor picks the first
-   *  writable provider in registration order. */
-  provider: Schema5.optional(Schema5.String)
-}) {
-};
-
-// src/oauth.ts
-import { Effect as Effect5, Schema as Schema6 } from "effect";
-var OAuthDynamicDcrStrategy = Schema6.Struct({
-  kind: Schema6.Literal("dynamic-dcr"),
-  /** Scopes to request. Defaults to whatever `scopes_supported`
-   *  advertises; caller can narrow or extend. */
-  scopes: Schema6.optional(Schema6.Array(Schema6.String))
-});
-var OAuthAuthorizationCodeStrategy = Schema6.Struct({
-  kind: Schema6.Literal("authorization-code"),
-  authorizationEndpoint: Schema6.String,
-  tokenEndpoint: Schema6.String,
-  /** Expected authorization-server issuer for ID token validation. Some
-   *  providers use a token endpoint host that differs from issuer, or a
-   *  path-scoped issuer such as Okta custom authorization servers. */
-  issuerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
-  /** Secret id holding the `client_id`. Using a secret row rather than
-   *  an inline string so the value lives at the scope where the caller
-   *  configured it and shadowing behaves consistently. */
-  clientIdSecretId: Schema6.String,
-  /** Secret id for `client_secret`. Null for public clients using
-   *  PKCE without a confidential secret. */
-  clientSecretSecretId: Schema6.NullOr(Schema6.String),
-  scopes: Schema6.Array(Schema6.String),
-  /** Separator between scopes. RFC 6749 says space; some providers
-   *  (GitHub classic) use comma. */
-  scopeSeparator: Schema6.optional(Schema6.String),
-  /** Provider-specific params injected at authorization URL build time
-   *  (Google's `access_type=offline`, `prompt=consent`, ...). */
-  extraAuthorizationParams: Schema6.optional(
-    Schema6.Record(Schema6.String, Schema6.String)
-  ),
-  /** `"body"` (default) sends client creds in the form body; `"basic"`
-   *  uses HTTP Basic auth. Stripe-style servers require basic. */
-  clientAuth: Schema6.optional(Schema6.Literals(["body", "basic"]))
-});
-var OAuthClientCredentialsStrategy = Schema6.Struct({
-  kind: Schema6.Literal("client-credentials"),
-  tokenEndpoint: Schema6.String,
-  clientIdSecretId: Schema6.String,
-  clientSecretSecretId: Schema6.String,
-  scopes: Schema6.optional(Schema6.Array(Schema6.String)),
-  scopeSeparator: Schema6.optional(Schema6.String),
-  clientAuth: Schema6.optional(Schema6.Literals(["body", "basic"]))
-});
-var OAuthStrategy = Schema6.Union([
-  OAuthDynamicDcrStrategy,
-  OAuthAuthorizationCodeStrategy,
-  OAuthClientCredentialsStrategy
-]);
-var OAuthProviderState = Schema6.Union([
-  Schema6.Struct({
-    kind: Schema6.Literal("dynamic-dcr"),
-    tokenEndpoint: Schema6.String,
-    issuerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
-    authorizationServerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
-    authorizationServerMetadataUrl: Schema6.NullOr(Schema6.String),
-    idTokenSigningAlgValuesSupported: Schema6.optional(
-      Schema6.Array(Schema6.String)
-    ),
-    /** DCR-minted client_id. Embedded inline (not a secret) — DCR
-     *  clients are public-ish by design; the secret part (if the AS
-     *  issued one) is a separate secret row. */
-    clientId: Schema6.String,
-    clientSecretSecretId: Schema6.NullOr(Schema6.String),
-    clientAuth: Schema6.Literals(["body", "basic"]),
-    scopes: Schema6.Array(Schema6.String).pipe(Schema6.withDecodingDefaultType(Effect5.succeed([]))),
-    scopeSeparator: Schema6.optional(Schema6.String),
-    scope: Schema6.NullOr(Schema6.String)
-  }),
-  Schema6.Struct({
-    kind: Schema6.Literal("authorization-code"),
-    tokenEndpoint: Schema6.String,
-    issuerUrl: Schema6.optional(Schema6.NullOr(Schema6.String)),
-    clientIdSecretId: Schema6.String,
-    clientSecretSecretId: Schema6.NullOr(Schema6.String),
-    clientAuth: Schema6.Literals(["body", "basic"]),
-    scopes: Schema6.Array(Schema6.String).pipe(Schema6.withDecodingDefaultType(Effect5.succeed([]))),
-    scopeSeparator: Schema6.optional(Schema6.String),
-    scope: Schema6.NullOr(Schema6.String)
-  }),
-  Schema6.Struct({
-    kind: Schema6.Literal("client-credentials"),
-    tokenEndpoint: Schema6.String,
-    clientIdSecretId: Schema6.String,
-    clientSecretSecretId: Schema6.String,
-    scopes: Schema6.Array(Schema6.String),
-    scopeSeparator: Schema6.optional(Schema6.String),
-    clientAuth: Schema6.Literals(["body", "basic"]),
-    scope: Schema6.NullOr(Schema6.String)
-  })
-]);
-var OAUTH2_PROVIDER_KEY = "oauth2";
-var OAuthProbeError = class extends Schema6.TaggedErrorClass()(
-  "OAuthProbeError",
-  {
-    message: Schema6.String
-  }
-) {
-  static annotations = { httpApiStatus: 400 };
-};
-var OAuthStartError = class extends Schema6.TaggedErrorClass()(
-  "OAuthStartError",
-  {
-    message: Schema6.String
-  }
-) {
-  static annotations = { httpApiStatus: 400 };
-};
-var OAuthCompleteError = class extends Schema6.TaggedErrorClass()(
-  "OAuthCompleteError",
-  {
-    message: Schema6.String,
-    /** RFC 6749 §5.2 error code, when the token endpoint returned one.
-     *  Callers distinguish terminal failures (`invalid_grant` ⇒
-     *  re-auth required) from transient ones. */
-    code: Schema6.optional(Schema6.String)
-  }
-) {
-  static annotations = { httpApiStatus: 400 };
-};
-var OAuthSessionNotFoundError = class extends Schema6.TaggedErrorClass()(
-  "OAuthSessionNotFoundError",
-  {
-    sessionId: Schema6.String
-  }
-) {
-  static annotations = { httpApiStatus: 404 };
-};
-var OAUTH2_SESSION_TTL_MS = 15 * 60 * 1e3;
-
-// src/oauth-helpers.ts
-import { Data as Data3, Effect as Effect6 } from "effect";
-import * as oauth from "oauth4webapi";
-var OAuth2Error = class extends Data3.TaggedError("OAuth2Error") {
-};
-var OAUTH2_REFRESH_SKEW_MS = 6e4;
-var OAUTH2_DEFAULT_TIMEOUT_MS = 2e4;
-var createPkceCodeVerifier = () => oauth.generateRandomCodeVerifier();
-var createPkceCodeChallenge = (verifier) => oauth.calculatePKCECodeChallenge(verifier);
-var buildAuthorizationUrl = (input) => {
-  const url = new URL(input.authorizationUrl);
-  const separator = input.scopeSeparator ?? " ";
-  url.searchParams.set("client_id", input.clientId);
-  url.searchParams.set("redirect_uri", input.redirectUrl);
-  url.searchParams.set("response_type", "code");
-  url.searchParams.set("scope", input.scopes.join(separator));
-  url.searchParams.set("state", input.state);
-  url.searchParams.set("code_challenge_method", "S256");
-  url.searchParams.set("code_challenge", input.codeChallenge);
-  if (input.extraParams) {
-    for (const [k, v] of Object.entries(input.extraParams)) {
-      url.searchParams.set(k, v);
-    }
-  }
-  return url.toString();
-};
-var toOAuth2Error = (cause) => {
-  if (typeof cause === "object" && cause !== null) {
-    const c = cause;
-    const code = typeof c.error === "string" ? c.error : void 0;
-    const description = typeof c.error_description === "string" ? c.error_description : typeof c.message === "string" ? c.message : void 0;
-    return new OAuth2Error({
-      message: `OAuth token exchange failed: ${description ?? code ?? "unknown error"}`,
-      error: code,
-      cause
-    });
-  }
-  return new OAuth2Error({
-    message: `OAuth token exchange failed: ${String(cause)}`,
-    cause
-  });
-};
-var asFromTokenUrl = (tokenUrl) => {
-  const url = new URL(tokenUrl);
-  return {
-    issuer: `${url.protocol}//${url.host}`,
-    token_endpoint: tokenUrl
-  };
-};
-var asFromTokenUrlAndIssuer = (tokenUrl, issuerUrl, options = {}) => {
-  const as = asFromTokenUrl(tokenUrl);
-  const withIssuer = issuerUrl ? { ...as, issuer: issuerUrl } : as;
-  return options.idTokenSigningAlgValuesSupported ? {
-    ...withIssuer,
-    id_token_signing_alg_values_supported: [
-      ...options.idTokenSigningAlgValuesSupported
-    ]
-  } : withIssuer;
-};
-var isLoopbackHttpUrl = (value) => {
-  try {
-    const url = new URL(value);
-    if (url.protocol !== "http:") return false;
-    const hostname = url.hostname.toLowerCase();
-    return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "[::1]" || hostname.startsWith("127.");
-  } catch {
-    return false;
-  }
-};
-var oauth4webapiRequestOptions = (targetUrl, timeoutMs) => {
-  const options = {
-    signal: AbortSignal.timeout(timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS)
-  };
-  if (isLoopbackHttpUrl(targetUrl)) {
-    options[oauth.allowInsecureRequests] = true;
-  }
-  return options;
-};
-var pickClientAuth = (clientSecret, method) => {
-  if (!clientSecret) return oauth.None();
-  return method === "basic" ? oauth.ClientSecretBasic(clientSecret) : oauth.ClientSecretPost(clientSecret);
-};
-var tokenResponseFrom = (r) => ({
-  access_token: r.access_token,
-  token_type: r.token_type,
-  refresh_token: r.refresh_token,
-  expires_in: typeof r.expires_in === "number" ? r.expires_in : void 0,
-  scope: r.scope
-});
-var isUnexpectedIdTokenAlg = (cause) => cause instanceof Error && cause.message.includes('unexpected JWT "alg" header parameter');
-var looseTokenResponseFrom = (body) => {
-  if (typeof body !== "object" || body === null) {
-    throw new Error("token endpoint response body is not an object");
-  }
-  const record = body;
-  if (typeof record.access_token !== "string" || !record.access_token) {
-    throw new Error('token endpoint response is missing "access_token"');
-  }
-  const expiresIn = typeof record.expires_in === "number" ? record.expires_in : typeof record.expires_in === "string" ? Number.parseFloat(record.expires_in) : void 0;
-  if (expiresIn !== void 0 && !Number.isFinite(expiresIn)) {
-    throw new Error('token endpoint response has invalid "expires_in"');
-  }
-  return {
-    access_token: record.access_token,
-    token_type: typeof record.token_type === "string" ? record.token_type : void 0,
-    refresh_token: typeof record.refresh_token === "string" ? record.refresh_token : void 0,
-    expires_in: expiresIn,
-    scope: typeof record.scope === "string" ? record.scope : void 0
-  };
-};
-var processTokenEndpointResponse = async (as, client, response) => {
-  const fallback = response.clone();
-  try {
-    return tokenResponseFrom(
-      await oauth.processGenericTokenEndpointResponse(as, client, response)
-    );
-  } catch (cause) {
-    if (!isUnexpectedIdTokenAlg(cause)) throw cause;
-    return looseTokenResponseFrom(await fallback.json());
-  }
-};
-var exchangeAuthorizationCode = (input) => Effect6.tryPromise({
-  try: async () => {
-    const as = asFromTokenUrlAndIssuer(input.tokenUrl, input.issuerUrl, {
-      idTokenSigningAlgValuesSupported: input.idTokenSigningAlgValuesSupported
-    });
-    const client = { client_id: input.clientId };
-    const clientAuth = pickClientAuth(
-      input.clientSecret,
-      input.clientAuth ?? "body"
-    );
-    const params = new URLSearchParams({
-      code: input.code,
-      redirect_uri: input.redirectUrl,
-      code_verifier: input.codeVerifier
-    });
-    const response = await oauth.genericTokenEndpointRequest(
-      as,
-      client,
-      clientAuth,
-      "authorization_code",
-      params,
-      oauth4webapiRequestOptions(input.tokenUrl, input.timeoutMs)
-    );
-    return processTokenEndpointResponse(as, client, response);
-  },
-  catch: toOAuth2Error
-});
-var exchangeClientCredentials = (input) => Effect6.tryPromise({
-  try: async () => {
-    const as = asFromTokenUrl(input.tokenUrl);
-    const client = { client_id: input.clientId };
-    const clientAuth = pickClientAuth(
-      input.clientSecret,
-      input.clientAuth ?? "body"
-    );
-    const params = new URLSearchParams();
-    if (input.scopes && input.scopes.length > 0) {
-      params.set("scope", input.scopes.join(input.scopeSeparator ?? " "));
-    }
-    const response = await oauth.clientCredentialsGrantRequest(
-      as,
-      client,
-      clientAuth,
-      params,
-      oauth4webapiRequestOptions(input.tokenUrl, input.timeoutMs)
-    );
-    const result = await oauth.processClientCredentialsResponse(
-      as,
-      client,
-      response
-    );
-    return tokenResponseFrom(result);
-  },
-  catch: toOAuth2Error
-});
-var refreshAccessToken = (input) => Effect6.tryPromise({
-  try: async () => {
-    const as = asFromTokenUrlAndIssuer(input.tokenUrl, input.issuerUrl, {
-      idTokenSigningAlgValuesSupported: input.idTokenSigningAlgValuesSupported
-    });
-    const client = { client_id: input.clientId };
-    const clientAuth = pickClientAuth(
-      input.clientSecret,
-      input.clientAuth ?? "body"
-    );
-    const additionalParameters = input.scopes && input.scopes.length > 0 ? new URLSearchParams({
-      scope: input.scopes.join(input.scopeSeparator ?? " ")
-    }) : void 0;
-    const response = await oauth.refreshTokenGrantRequest(
-      as,
-      client,
-      clientAuth,
-      input.refreshToken,
-      {
-        ...oauth4webapiRequestOptions(input.tokenUrl, input.timeoutMs),
-        additionalParameters
-      }
-    );
-    const fallback = response.clone();
-    try {
-      const result = await oauth.processRefreshTokenResponse(
-        as,
-        client,
-        response
-      );
-      return tokenResponseFrom(result);
-    } catch (cause) {
-      if (!isUnexpectedIdTokenAlg(cause)) throw cause;
-      return looseTokenResponseFrom(await fallback.json());
-    }
-  },
-  catch: toOAuth2Error
-});
-var shouldRefreshToken = (input) => {
-  if (input.expiresAt === null) return false;
-  const now = input.now ?? Date.now();
-  const skew = input.skewMs ?? OAUTH2_REFRESH_SKEW_MS;
-  return input.expiresAt <= now + skew;
-};
-
-// src/oauth-discovery.ts
-import { Data as Data4, Effect as Effect7, Result, Schema as Schema7 } from "effect";
-import * as oauth2 from "oauth4webapi";
-var OAuthDiscoveryError = class extends Data4.TaggedError(
-  "OAuthDiscoveryError"
-) {
-};
-var discoveryError = (message, options = {}) => new OAuthDiscoveryError({
-  message,
-  status: options.status,
-  cause: options.cause
-});
-var StringArray = Schema7.Array(Schema7.String);
-var OAuthProtectedResourceMetadataSchema = Schema7.Struct({
-  resource: Schema7.optional(Schema7.String),
-  authorization_servers: Schema7.optional(StringArray),
-  scopes_supported: Schema7.optional(StringArray),
-  bearer_methods_supported: Schema7.optional(StringArray),
-  resource_documentation: Schema7.optional(Schema7.String)
-}).annotate({ identifier: "OAuthProtectedResourceMetadata" });
-var OAuthAuthorizationServerMetadataSchema = Schema7.Struct({
-  issuer: Schema7.String,
-  authorization_endpoint: Schema7.String,
-  token_endpoint: Schema7.String,
-  registration_endpoint: Schema7.optional(Schema7.String),
-  scopes_supported: Schema7.optional(StringArray),
-  response_types_supported: Schema7.optional(StringArray),
-  grant_types_supported: Schema7.optional(StringArray),
-  code_challenge_methods_supported: Schema7.optional(StringArray),
-  token_endpoint_auth_methods_supported: Schema7.optional(StringArray),
-  revocation_endpoint: Schema7.optional(Schema7.String),
-  introspection_endpoint: Schema7.optional(Schema7.String),
-  userinfo_endpoint: Schema7.optional(Schema7.String),
-  id_token_signing_alg_values_supported: Schema7.optional(StringArray)
-}).annotate({ identifier: "OAuthAuthorizationServerMetadata" });
-var OAuthClientInformationSchema = Schema7.Struct({
-  client_id: Schema7.String,
-  client_secret: Schema7.optional(Schema7.String),
-  client_id_issued_at: Schema7.optional(Schema7.Number),
-  client_secret_expires_at: Schema7.optional(Schema7.Number),
-  registration_access_token: Schema7.optional(Schema7.String),
-  registration_client_uri: Schema7.optional(Schema7.String),
-  token_endpoint_auth_method: Schema7.optional(Schema7.String),
-  grant_types: Schema7.optional(StringArray),
-  response_types: Schema7.optional(StringArray),
-  redirect_uris: Schema7.optional(StringArray),
-  client_name: Schema7.optional(Schema7.String),
-  scope: Schema7.optional(Schema7.String)
-}).annotate({ identifier: "OAuthClientInformation" });
-var decodeResourceMetadata = Schema7.decodeUnknownEffect(
-  OAuthProtectedResourceMetadataSchema
-);
-var decodeAuthServerMetadata = Schema7.decodeUnknownEffect(
-  OAuthAuthorizationServerMetadataSchema
-);
-var decodeClientInformation = Schema7.decodeUnknownEffect(
-  OAuthClientInformationSchema
-);
-var MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
-var isLoopbackHttpUrl2 = (value) => {
-  try {
-    const url = new URL(value);
-    if (url.protocol !== "http:") return false;
-    const hostname = url.hostname.toLowerCase();
-    return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "[::1]" || hostname.startsWith("127.");
-  } catch {
-    return false;
-  }
-};
-var oauth4webapiOptions = (options, targetUrl) => {
-  const out = {};
-  if (options.fetch) out[customFetch] = options.fetch;
-  if (targetUrl && isLoopbackHttpUrl2(targetUrl)) {
-    out[oauth2.allowInsecureRequests] = true;
-  }
-  const signal = AbortSignal.timeout(options.timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS);
-  out.signal = signal;
-  if (options.mcpProtocolVersion) {
-    out.headers = new Headers({
-      [MCP_PROTOCOL_VERSION_HEADER]: options.mcpProtocolVersion
-    });
-  }
-  return out;
-};
-var customFetch = /* @__PURE__ */ Symbol.for("oauth4webapi.customFetch");
-var buildResourceMetadataUrls = (resourceUrl) => {
-  const url = new URL(resourceUrl);
-  const origin = `${url.protocol}//${url.host}`;
-  const path = url.pathname.replace(/\/+$/, "");
-  const urls = [];
-  if (path && path !== "/") {
-    urls.push(`${origin}/.well-known/oauth-protected-resource${path}`);
-  }
-  urls.push(`${origin}/.well-known/oauth-protected-resource`);
-  return urls;
-};
-var withResourceQueryParams = (url, queryParams) => {
-  if (!queryParams || Object.keys(queryParams).length === 0) return url;
-  const parsed = new URL(url);
-  for (const [key, value] of Object.entries(queryParams)) {
-    parsed.searchParams.set(key, value);
-  }
-  return parsed.toString();
-};
-var discoverProtectedResourceMetadata = (resourceUrl, options = {}) => Effect7.gen(function* () {
-  const fetchImpl = options.fetch ?? globalThis.fetch;
-  const timeoutMs = options.timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS;
-  for (const url of buildResourceMetadataUrls(resourceUrl)) {
-    const result = yield* Effect7.tryPromise({
-      try: async () => {
-        const requestUrl = withResourceQueryParams(url, options.resourceQueryParams);
-        const headers = {
-          ...options.resourceHeaders,
-          accept: "application/json"
-        };
-        if (options.mcpProtocolVersion) {
-          headers[MCP_PROTOCOL_VERSION_HEADER] = options.mcpProtocolVersion;
-        }
-        const response = await fetchImpl(requestUrl, {
-          method: "GET",
-          headers,
-          signal: AbortSignal.timeout(timeoutMs)
-        });
-        if (response.status === 404 || response.status === 405) return "skip";
-        if (response.status < 200 || response.status >= 300) {
-          return { status: response.status };
-        }
-        const text = await response.text();
-        if (text.length === 0) return "skip";
-        return { status: response.status, body: JSON.parse(text) };
-      },
-      catch: (cause) => discoveryError(
-        `Failed to fetch ${url}: ${cause instanceof Error ? cause.message : String(cause)}`,
-        { cause }
-      )
-    });
-    if (result === "skip") continue;
-    if (!("body" in result)) {
-      return yield* Effect7.fail(
-        discoveryError(
-          `Protected resource metadata returned status ${result.status}`,
-          { status: result.status }
-        )
-      );
-    }
-    const metadata = yield* decodeResourceMetadata(result.body).pipe(
-      Effect7.mapError(
-        (err) => new OAuthDiscoveryError({
-          message: `Protected resource metadata is malformed: ${Schema7.isSchemaError(err) ? err.message : String(err)}`,
-          cause: err
-        })
-      )
-    );
-    return { metadataUrl: url, metadata };
-  }
-  return null;
-});
-var wellKnownUrlFor = (issuerOrigin, algorithm, issuerPath) => {
-  const suffix = algorithm === "oauth2" ? "oauth-authorization-server" : "openid-configuration";
-  return issuerPath && issuerPath !== "/" ? `${issuerOrigin}/.well-known/${suffix}${issuerPath}` : `${issuerOrigin}/.well-known/${suffix}`;
-};
-var discoverAuthorizationServerMetadata = (issuer, options = {}) => Effect7.gen(function* () {
-  const issuerUrl = new URL(issuer);
-  const issuerOrigin = `${issuerUrl.protocol}//${issuerUrl.host}`;
-  const issuerPath = issuerUrl.pathname.replace(/\/+$/, "");
-  for (const algorithm of ["oauth2", "oidc"]) {
-    const result = yield* Effect7.tryPromise({
-      try: async () => {
-        const response = await oauth2.discoveryRequest(issuerUrl, {
-          algorithm,
-          ...oauth4webapiOptions(options, issuer)
-        });
-        if (response.status === 404 || response.status === 405) {
-          return null;
-        }
-        const as = await oauth2.processDiscoveryResponse(issuerUrl, response);
-        return {
-          metadataUrl: wellKnownUrlFor(issuerOrigin, algorithm, issuerPath),
-          raw: as
-        };
-      },
-      catch: (cause) => {
-        if (cause instanceof OAuthDiscoveryError) return cause;
-        return discoveryError(
-          `Discovery (${algorithm}) failed for ${issuer}: ${cause instanceof Error ? cause.message : String(cause)}`,
-          { cause }
-        );
-      }
-    }).pipe(
-      // If one algorithm fails mid-roundtrip (network, parse, issuer
-      // mismatch) we still want to try the other before giving up.
-      Effect7.result
-    );
-    if (Result.isFailure(result)) continue;
-    if (result.success === null) continue;
-    const metadata = yield* decodeAuthServerMetadata(result.success.raw).pipe(
-      Effect7.mapError(
-        (err) => new OAuthDiscoveryError({
-          message: `Authorization server metadata is malformed: ${Schema7.isSchemaError(err) ? err.message : String(err)}`,
-          cause: err
-        })
-      )
-    );
-    return { metadataUrl: result.success.metadataUrl, metadata };
-  }
-  return null;
-});
-var DcrErrorBody = class extends Data4.TaggedError("DcrErrorBody") {
-};
-var DcrTransport = class extends Data4.TaggedError("DcrTransport") {
-};
-var buildDcrBody = (m) => {
-  const body = { redirect_uris: [...m.redirect_uris] };
-  if (m.client_name !== void 0) body.client_name = m.client_name;
-  if (m.grant_types !== void 0) body.grant_types = [...m.grant_types];
-  if (m.response_types !== void 0) body.response_types = [...m.response_types];
-  if (m.token_endpoint_auth_method !== void 0) {
-    body.token_endpoint_auth_method = m.token_endpoint_auth_method;
-  }
-  if (m.scope !== void 0) body.scope = m.scope;
-  if (m.application_type !== void 0) body.application_type = m.application_type;
-  if (m.client_uri !== void 0) body.client_uri = m.client_uri;
-  if (m.logo_uri !== void 0) body.logo_uri = m.logo_uri;
-  if (m.contacts !== void 0) body.contacts = [...m.contacts];
-  if (m.software_id !== void 0) body.software_id = m.software_id;
-  if (m.software_version !== void 0) body.software_version = m.software_version;
-  if (m.extra) for (const [k, v] of Object.entries(m.extra)) body[k] = v;
-  return body;
-};
-var interpretDcrFailure = (status, text) => {
-  if (status >= 400 && status < 500) {
-    const parsed = Result.try({
-      try: () => text ? JSON.parse(text) : null,
-      catch: () => null
-    });
-    const body = Result.isSuccess(parsed) ? parsed.success : null;
-    if (body && typeof body === "object" && "error" in body && typeof body.error === "string" && body.error.length > 0) {
-      const desc = "error_description" in body && typeof body.error_description === "string" ? body.error_description : void 0;
-      return new DcrErrorBody({ status, error: body.error, error_description: desc });
-    }
-  }
-  return new DcrTransport({
-    message: `Dynamic Client Registration endpoint returned status ${status}${text ? ` \u2014 ${text.slice(0, 200)}` : ""}`,
-    status
-  });
-};
-var registerDynamicClient = (input, options = {}) => Effect7.gen(function* () {
-  const url = new URL(input.registrationEndpoint);
-  if (url.protocol !== "https:" && !isLoopbackHttpUrl2(input.registrationEndpoint)) {
-    return yield* new DcrTransport({
-      message: `registration_endpoint must be HTTPS or a loopback HTTP URL (got ${url.protocol}//${url.host})`
-    });
-  }
-  const headers = {
-    "content-type": "application/json",
-    accept: "application/json"
-  };
-  if (input.initialAccessToken) {
-    headers.authorization = `Bearer ${input.initialAccessToken}`;
-  }
-  const fetchImpl = options.fetch ?? globalThis.fetch;
-  const timeoutMs = options.timeoutMs ?? OAUTH2_DEFAULT_TIMEOUT_MS;
-  const response = yield* Effect7.tryPromise({
-    try: () => fetchImpl(input.registrationEndpoint, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(buildDcrBody(input.metadata)),
-      signal: AbortSignal.timeout(timeoutMs)
-    }),
-    catch: (cause) => new DcrTransport({
-      message: `Dynamic Client Registration request failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-      cause
-    })
-  });
-  if (response.status !== 200 && response.status !== 201) {
-    const text2 = yield* Effect7.promise(
-      () => response.text().catch(() => "")
-    );
-    return yield* interpretDcrFailure(response.status, text2);
-  }
-  const text = yield* Effect7.tryPromise({
-    try: () => response.text(),
-    catch: (cause) => new DcrTransport({
-      message: "Dynamic Client Registration response could not be read",
-      status: response.status,
-      cause
-    })
-  });
-  const json = yield* Effect7.try({
-    try: () => JSON.parse(text),
-    catch: (cause) => new DcrTransport({
-      message: "Dynamic Client Registration response was not valid JSON",
-      status: response.status,
-      cause
-    })
-  });
-  return yield* decodeClientInformation(json).pipe(
-    Effect7.mapError(
-      (err) => new OAuthDiscoveryError({
-        message: `Dynamic Client Registration response is malformed: ${Schema7.isSchemaError(err) ? err.message : String(err)}`,
-        cause: err
-      })
-    )
-  );
-}).pipe(
-  Effect7.catchTags({
-    DcrErrorBody: (err) => Effect7.fail(
-      discoveryError(
-        `Dynamic Client Registration failed: ${err.error}${err.error_description ? ` \u2014 ${err.error_description}` : ""}`,
-        { status: err.status, cause: err }
-      )
-    ),
-    DcrTransport: (err) => Effect7.fail(
-      discoveryError(`Dynamic Client Registration failed: ${err.message}`, {
-        status: err.status,
-        cause: err.cause ?? err
-      })
-    )
-  })
-);
-var beginDynamicAuthorization = (input, options = {}) => Effect7.gen(function* () {
-  const prior = input.previousState ?? {};
-  const canSkipResourceDiscovery = prior.resourceMetadata !== void 0 || !!prior.authorizationServerUrl || !!prior.authorizationServerMetadata;
-  const resource = canSkipResourceDiscovery ? prior.resourceMetadata ? {
-    metadata: prior.resourceMetadata,
-    metadataUrl: prior.resourceMetadataUrl ?? null
-  } : null : yield* discoverProtectedResourceMetadata(input.endpoint, options);
-  const authorizationServerUrl = (() => {
-    if (prior.authorizationServerUrl) return prior.authorizationServerUrl;
-    const fromResource = resource && resource.metadata.authorization_servers?.[0];
-    if (fromResource) return fromResource;
-    const u = new URL(input.endpoint);
-    return `${u.protocol}//${u.host}`;
-  })();
-  const authServer = prior.authorizationServerMetadata && prior.authorizationServerMetadataUrl ? {
-    metadata: prior.authorizationServerMetadata,
-    metadataUrl: prior.authorizationServerMetadataUrl
-  } : yield* discoverAuthorizationServerMetadata(
-    authorizationServerUrl,
-    options
-  );
-  if (!authServer) {
-    return yield* Effect7.fail(
-      discoveryError(
-        `No OAuth authorization server metadata at ${authorizationServerUrl}`
-      )
-    );
-  }
-  const pkceMethods = authServer.metadata.code_challenge_methods_supported ?? [];
-  if (pkceMethods.length > 0 && !pkceMethods.includes("S256")) {
-    return yield* Effect7.fail(
-      discoveryError(
-        `Authorization server does not support PKCE S256 (advertised: ${pkceMethods.join(", ")})`
-      )
-    );
-  }
-  const responseTypes = authServer.metadata.response_types_supported ?? [];
-  if (responseTypes.length > 0 && !responseTypes.includes("code")) {
-    return yield* Effect7.fail(
-      discoveryError(
-        `Authorization server does not support response_type=code (advertised: ${responseTypes.join(", ")})`
-      )
-    );
-  }
-  const baseClientMetadata = {
-    grant_types: ["authorization_code", "refresh_token"],
-    response_types: ["code"],
-    token_endpoint_auth_method: "none",
-    client_name: "Executor",
-    ...input.clientMetadata ?? {},
-    redirect_uris: input.clientMetadata?.redirect_uris ?? [input.redirectUrl]
-  };
-  const clientInformation = prior.clientInformation ?? (yield* (() => {
-    const reg = authServer.metadata.registration_endpoint;
-    if (!reg) {
-      return Effect7.fail(
-        discoveryError(
-          "Authorization server does not advertise registration_endpoint \u2014 cannot auto-register a client"
-        )
-      );
-    }
-    return registerDynamicClient(
-      { registrationEndpoint: reg, metadata: baseClientMetadata },
-      options
-    );
-  })());
-  const codeVerifier = createPkceCodeVerifier();
-  const codeChallenge = yield* Effect7.promise(
-    () => createPkceCodeChallenge(codeVerifier)
-  );
-  const scopes = input.scopes ?? authServer.metadata.scopes_supported ?? [];
-  const authorizationUrl = buildAuthorizationUrl({
-    authorizationUrl: authServer.metadata.authorization_endpoint,
-    clientId: clientInformation.client_id,
-    redirectUrl: input.redirectUrl,
-    scopes,
-    state: input.state,
-    codeChallenge
-  });
-  return {
-    authorizationUrl,
-    codeVerifier,
-    state: {
-      resourceMetadata: resource?.metadata ?? null,
-      resourceMetadataUrl: resource?.metadataUrl ?? null,
-      authorizationServerUrl,
-      authorizationServerMetadataUrl: authServer.metadataUrl,
-      authorizationServerMetadata: authServer.metadata,
-      clientInformation
-    }
-  };
-});
-
-// src/oauth-service.ts
-import { Effect as Effect8, Schema as Schema8 } from "effect";
-var OAuthAuthorizationServerMetadataJson = Schema8.Record(Schema8.String, Schema8.Unknown);
-var OAuthClientInformationJson = Schema8.Record(Schema8.String, Schema8.Unknown);
-var DynamicDcrSessionPayload = Schema8.Struct({
-  kind: Schema8.Literal("dynamic-dcr"),
-  identityLabel: Schema8.NullOr(Schema8.String),
-  codeVerifier: Schema8.String,
-  authorizationServerUrl: Schema8.String,
-  authorizationServerMetadataUrl: Schema8.String,
-  authorizationServerMetadata: OAuthAuthorizationServerMetadataJson,
-  clientInformation: OAuthClientInformationJson,
-  resourceMetadataUrl: Schema8.NullOr(Schema8.String),
-  resourceMetadata: Schema8.NullOr(
-    Schema8.Record(Schema8.String, Schema8.Unknown)
-  ),
-  scopes: Schema8.Array(Schema8.String)
-});
-var AuthorizationCodeSessionPayload = Schema8.Struct({
-  kind: Schema8.Literal("authorization-code"),
-  identityLabel: Schema8.NullOr(Schema8.String),
-  codeVerifier: Schema8.String,
-  authorizationEndpoint: Schema8.String,
-  tokenEndpoint: Schema8.String,
-  issuerUrl: Schema8.NullOr(Schema8.String).pipe(Schema8.withDecodingDefaultType(Effect8.succeed(null))),
-  clientIdSecretId: Schema8.String,
-  clientSecretSecretId: Schema8.NullOr(Schema8.String),
-  scopes: Schema8.Array(Schema8.String),
-  scopeSeparator: Schema8.optional(Schema8.String),
-  clientAuth: Schema8.Literals(["body", "basic"])
-});
-var OAuthSessionPayload = Schema8.Union([
-  DynamicDcrSessionPayload,
-  AuthorizationCodeSessionPayload
-]);
-var decodeSessionPayload = Schema8.decodeUnknownSync(OAuthSessionPayload);
-var encodeSessionPayload = Schema8.encodeSync(OAuthSessionPayload);
-var coerceJson = (value) => {
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-};
-var stringArray = (value) => Array.isArray(value) ? value.filter((scope) => typeof scope === "string") : [];
-var originOrNull = (value) => {
-  if (typeof value !== "string") return null;
-  try {
-    return new URL(value).origin;
-  } catch {
-    return null;
-  }
-};
-var decodeProviderState = (value) => {
-  const raw = coerceJson(value);
-  const record = raw && typeof raw === "object" ? raw : null;
-  if (record && !("kind" in record) && "flow" in record && "tokenUrl" in record) {
-    const flow = record.flow;
-    if (flow === "authorizationCode") {
-      return Schema8.decodeUnknownSync(OAuthProviderState)({
-        kind: "authorization-code",
-        tokenEndpoint: record.tokenUrl,
-        issuerUrl: originOrNull(record.authorizationEndpoint),
-        clientIdSecretId: record.clientIdSecretId,
-        clientSecretSecretId: record.clientSecretSecretId ?? null,
-        clientAuth: "body",
-        scope: stringArray(record.scopes).join(" ") || null
-      });
-    }
-    if (flow === "clientCredentials") {
-      return Schema8.decodeUnknownSync(OAuthProviderState)({
-        kind: "client-credentials",
-        tokenEndpoint: record.tokenUrl,
-        clientIdSecretId: record.clientIdSecretId,
-        clientSecretSecretId: record.clientSecretSecretId,
-        scopes: stringArray(record.scopes),
-        clientAuth: "body",
-        scope: stringArray(record.scopes).join(" ") || null
-      });
-    }
-  }
-  if (record && !("kind" in record) && "clientIdSecretId" in record && "scopes" in record) {
-    const scopes = stringArray(record.scopes);
-    return Schema8.decodeUnknownSync(OAuthProviderState)({
-      kind: "authorization-code",
-      tokenEndpoint: "https://oauth2.googleapis.com/token",
-      issuerUrl: "https://accounts.google.com",
-      clientIdSecretId: record.clientIdSecretId,
-      clientSecretSecretId: record.clientSecretSecretId ?? null,
-      clientAuth: "body",
-      scope: scopes.join(" ") || null
-    });
-  }
-  if (record && !("kind" in record) && "clientInformation" in record && "endpoint" in record) {
-    const clientInformation = record.clientInformation && typeof record.clientInformation === "object" ? record.clientInformation : null;
-    return Schema8.decodeUnknownSync(OAuthProviderState)({
-      kind: "dynamic-dcr",
-      tokenEndpoint: typeof record.tokenEndpoint === "string" ? record.tokenEndpoint : record.authorizationServerMetadata && typeof record.authorizationServerMetadata === "object" && typeof record.authorizationServerMetadata.token_endpoint === "string" ? record.authorizationServerMetadata.token_endpoint : "",
-      issuerUrl: record.authorizationServerMetadata && typeof record.authorizationServerMetadata === "object" && typeof record.authorizationServerMetadata.issuer === "string" ? record.authorizationServerMetadata.issuer : null,
-      authorizationServerUrl: typeof record.authorizationServerUrl === "string" ? record.authorizationServerUrl : null,
-      authorizationServerMetadataUrl: typeof record.authorizationServerMetadataUrl === "string" ? record.authorizationServerMetadataUrl : null,
-      clientId: typeof clientInformation?.client_id === "string" ? clientInformation.client_id : "",
-      clientSecretSecretId: null,
-      clientAuth: "body",
-      scope: null
-    });
-  }
-  return Schema8.decodeUnknownSync(OAuthProviderState)(raw);
-};
-var defaultSessionId = () => {
-  const crypto = globalThis.crypto;
-  if (crypto?.randomUUID) return `oauth2_session_${crypto.randomUUID()}`;
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  return `oauth2_session_${Array.from(
-    bytes,
-    (byte) => byte.toString(16).padStart(2, "0")
-  ).join("")}`;
-};
-var secretIdPart = (value) => value.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "oauth";
-var oauthSecretId = (connectionId, suffix) => {
-  const base = secretIdPart(connectionId);
-  const readable = base.length <= 48 ? base : base.slice(0, 40);
-  return `oauth2-${readable}-${suffix}`;
-};
-var scopedSessionId = (scopeId, sessionId) => `${sessionId}_${secretIdPart(scopeId).slice(0, 24)}`;
-var terminalRefreshErrors = /* @__PURE__ */ new Set([
-  "invalid_grant",
-  "invalid_client",
-  "unauthorized_client"
-]);
-var makeOAuth2Service = (deps) => {
-  const now = deps.now ?? (() => Date.now());
-  const newSessionId = deps.newSessionId ?? defaultSessionId;
-  const probe = (input) => Effect8.gen(function* () {
-    const resource = yield* discoverProtectedResourceMetadata(
-      input.endpoint,
-      { resourceHeaders: input.headers, resourceQueryParams: input.queryParams }
-    ).pipe(
-      Effect8.catchTag(
-        "OAuthDiscoveryError",
-        (err) => Effect8.fail(
-          new OAuthProbeError({
-            message: `Protected resource metadata probe failed: ${err.message}`
-          })
-        )
-      )
-    );
-    const authorizationServerUrl = (() => {
-      const fromResource = resource?.metadata.authorization_servers?.[0];
-      if (fromResource) return fromResource;
-      try {
-        const u = new URL(input.endpoint);
-        return `${u.protocol}//${u.host}`;
-      } catch {
-        return null;
-      }
-    })();
-    const authServer = authorizationServerUrl ? yield* discoverAuthorizationServerMetadata(
-      authorizationServerUrl
-    ).pipe(
-      Effect8.catchTag(
-        "OAuthDiscoveryError",
-        () => Effect8.succeed(null)
-      )
-    ) : null;
-    const supportsDynamicRegistration = !!(authServer?.metadata.registration_endpoint && (authServer.metadata.token_endpoint_auth_methods_supported ?? []).includes(
-      "none"
-    ));
-    const isBearerChallengeEndpoint = yield* Effect8.tryPromise({
-      try: async () => {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 6e3);
-        try {
-          const probeUrl = new URL(input.endpoint);
-          for (const [key, value] of Object.entries(input.queryParams ?? {})) {
-            probeUrl.searchParams.set(key, value);
-          }
-          const response = await fetch(probeUrl.toString(), {
-            method: "POST",
-            headers: {
-              ...input.headers ?? {},
-              "content-type": "application/json",
-              accept: "application/json, text/event-stream"
-            },
-            body: JSON.stringify({
-              jsonrpc: "2.0",
-              id: 1,
-              method: "initialize",
-              params: {
-                protocolVersion: "2025-06-18",
-                capabilities: {},
-                clientInfo: { name: "executor-probe", version: "0" }
-              }
-            }),
-            signal: controller.signal
-          });
-          if (response.status !== 401) return false;
-          const wwwAuth = response.headers.get("www-authenticate") ?? response.headers.get("WWW-Authenticate");
-          return !!wwwAuth && /^\s*bearer\b/i.test(wwwAuth);
-        } finally {
-          clearTimeout(timer);
-        }
-      },
-      catch: () => null
-    }).pipe(Effect8.catch(() => Effect8.succeed(false)));
-    return {
-      resourceMetadata: resource?.metadata ?? null,
-      resourceMetadataUrl: resource?.metadataUrl ?? null,
-      authorizationServerMetadata: authServer?.metadata ?? null,
-      authorizationServerMetadataUrl: authServer?.metadataUrl ?? null,
-      authorizationServerUrl: authorizationServerUrl ?? null,
-      supportsDynamicRegistration,
-      isBearerChallengeEndpoint
-    };
-  });
-  const startDynamicDcr = (input, strategy) => Effect8.gen(function* () {
-    const started = yield* beginDynamicAuthorization({
-      endpoint: input.endpoint,
-      redirectUrl: input.redirectUrl,
-      state: "",
-      scopes: strategy.scopes
-    }, {
-      resourceHeaders: input.headers,
-      resourceQueryParams: input.queryParams
-    }).pipe(
-      Effect8.catchTag(
-        "OAuthDiscoveryError",
-        (err) => Effect8.fail(
-          new OAuthStartError({
-            message: `Dynamic authorization setup failed: ${err.message}`
-          })
-        )
-      )
-    );
-    const sessionId = scopedSessionId(input.tokenScope, newSessionId());
-    const codeChallenge = yield* Effect8.promise(
-      () => createPkceCodeChallenge(started.codeVerifier)
-    );
-    const authorizationUrl = buildAuthorizationUrl({
-      authorizationUrl: started.state.authorizationServerMetadata.authorization_endpoint,
-      clientId: started.state.clientInformation.client_id,
-      redirectUrl: input.redirectUrl,
-      scopes: strategy.scopes ?? started.state.authorizationServerMetadata.scopes_supported ?? [],
-      state: sessionId,
-      codeChallenge
-    });
-    const payload = {
-      kind: "dynamic-dcr",
-      identityLabel: input.identityLabel ?? null,
-      codeVerifier: started.codeVerifier,
-      authorizationServerUrl: started.state.authorizationServerUrl,
-      authorizationServerMetadataUrl: started.state.authorizationServerMetadataUrl,
-      authorizationServerMetadata: started.state.authorizationServerMetadata,
-      clientInformation: (() => {
-        const value = started.state.clientInformation;
-        return value;
-      })(),
-      resourceMetadataUrl: started.state.resourceMetadataUrl,
-      resourceMetadata: started.state.resourceMetadata ?? null,
-      scopes: [
-        ...strategy.scopes ?? started.state.authorizationServerMetadata.scopes_supported ?? []
-      ]
-    };
-    yield* writeSession({
-      sessionId,
-      input,
-      payload,
-      strategyKind: "dynamic-dcr"
-    });
-    return {
-      sessionId,
-      authorizationUrl,
-      completedConnection: null
-    };
-  });
-  const startAuthorizationCode = (input, strategy) => Effect8.gen(function* () {
-    const clientId = yield* deps.secretsGet(strategy.clientIdSecretId).pipe(
-      Effect8.mapError(
-        (err) => (
-          // Storage failure propagates; null returns aren't errors — the
-          // branch below handles them.
-          err
-        )
-      )
-    );
-    if (clientId === null) {
-      return yield* Effect8.fail(
-        new OAuthStartError({
-          message: `client_id secret "${strategy.clientIdSecretId}" not found`
-        })
-      );
-    }
-    const sessionId = scopedSessionId(input.tokenScope, newSessionId());
-    const codeVerifier = createPkceCodeVerifier();
-    const codeChallenge = yield* Effect8.promise(
-      () => createPkceCodeChallenge(codeVerifier)
-    );
-    const authorizationUrl = buildAuthorizationUrl({
-      authorizationUrl: strategy.authorizationEndpoint,
-      clientId,
-      redirectUrl: input.redirectUrl,
-      scopes: strategy.scopes,
-      state: sessionId,
-      codeChallenge,
-      scopeSeparator: strategy.scopeSeparator,
-      extraParams: strategy.extraAuthorizationParams
-    });
-    const payload = {
-      kind: "authorization-code",
-      identityLabel: input.identityLabel ?? null,
-      codeVerifier,
-      authorizationEndpoint: strategy.authorizationEndpoint,
-      tokenEndpoint: strategy.tokenEndpoint,
-      issuerUrl: strategy.issuerUrl ?? new URL(strategy.authorizationEndpoint).origin,
-      clientIdSecretId: strategy.clientIdSecretId,
-      clientSecretSecretId: strategy.clientSecretSecretId,
-      scopes: [...strategy.scopes],
-      scopeSeparator: strategy.scopeSeparator,
-      clientAuth: strategy.clientAuth ?? "body"
-    };
-    yield* writeSession({
-      sessionId,
-      input,
-      payload,
-      strategyKind: "authorization-code"
-    });
-    return {
-      sessionId,
-      authorizationUrl,
-      completedConnection: null
-    };
-  });
-  const startClientCredentials = (input, strategy) => Effect8.gen(function* () {
-    const clientId = yield* deps.secretsGet(strategy.clientIdSecretId);
-    const clientSecret = yield* deps.secretsGet(strategy.clientSecretSecretId);
-    if (clientId === null || clientSecret === null) {
-      return yield* Effect8.fail(
-        new OAuthStartError({
-          message: "client_id / client_secret secret not found"
-        })
-      );
-    }
-    const tokens = yield* exchangeClientCredentials({
-      tokenUrl: strategy.tokenEndpoint,
-      clientId,
-      clientSecret,
-      scopes: strategy.scopes,
-      scopeSeparator: strategy.scopeSeparator,
-      clientAuth: strategy.clientAuth ?? "body"
-    }).pipe(
-      Effect8.mapError(
-        (err) => new OAuthStartError({
-          message: `Client credentials exchange failed: ${err.message}`
-        })
-      )
-    );
-    const expiresAt = typeof tokens.expires_in === "number" ? now() + tokens.expires_in * 1e3 : null;
-    const providerState = {
-      kind: "client-credentials",
-      tokenEndpoint: strategy.tokenEndpoint,
-      clientIdSecretId: strategy.clientIdSecretId,
-      clientSecretSecretId: strategy.clientSecretSecretId,
-      scopes: [...strategy.scopes ?? []],
-      scopeSeparator: strategy.scopeSeparator,
-      clientAuth: strategy.clientAuth ?? "body",
-      scope: tokens.scope ?? null
-    };
-    yield* deps.connectionsCreate(
-      new CreateConnectionInput({
-        id: ConnectionId.make(input.connectionId),
-        scope: ScopeId.make(input.tokenScope),
-        provider: OAUTH2_PROVIDER_KEY,
-        identityLabel: input.identityLabel ?? safeHostname(input.endpoint),
-        accessToken: new TokenMaterial({
-          secretId: SecretId.make(oauthSecretId(input.connectionId, "access-token")),
-          name: "OAuth Access Token",
-          value: tokens.access_token
-        }),
-        refreshToken: null,
-        expiresAt,
-        oauthScope: tokens.scope ?? null,
-        providerState: Schema8.encodeSync(OAuthProviderState)(
-          providerState
-        )
-      })
-    ).pipe(
-      Effect8.mapError(
-        (err) => new OAuthStartError({
-          message: `Failed to mint connection: ${err instanceof Error ? err.message : String(err)}`
-        })
-      )
-    );
-    return {
-      sessionId: "",
-      authorizationUrl: null,
-      completedConnection: { connectionId: input.connectionId }
-    };
-  });
-  const start = (input) => {
-    switch (input.strategy.kind) {
-      case "dynamic-dcr":
-        return startDynamicDcr(input, input.strategy);
-      case "authorization-code":
-        return startAuthorizationCode(input, input.strategy);
-      case "client-credentials":
-        return startClientCredentials(input, input.strategy);
-    }
-  };
-  const writeSession = (args) => deps.adapter.create({
-    model: "oauth2_session",
-    data: {
-      id: args.sessionId,
-      scope_id: args.input.tokenScope,
-      plugin_id: args.input.pluginId,
-      strategy: args.strategyKind,
-      connection_id: args.input.connectionId,
-      token_scope: args.input.tokenScope,
-      redirect_url: args.input.redirectUrl,
-      payload: encodeSessionPayload(args.payload),
-      expires_at: now() + OAUTH2_SESSION_TTL_MS,
-      created_at: /* @__PURE__ */ new Date()
-    },
-    forceAllowId: true
-  }).pipe(Effect8.asVoid);
-  const complete = (input) => Effect8.gen(function* () {
-    const row = yield* deps.adapter.findOne({
-      model: "oauth2_session",
-      where: [{ field: "id", value: input.state }]
-    });
-    if (!row) {
-      return yield* Effect8.fail(
-        new OAuthSessionNotFoundError({ sessionId: input.state })
-      );
-    }
-    const deleteSession = deps.adapter.delete({
-      model: "oauth2_session",
-      where: [
-        { field: "id", value: input.state },
-        { field: "scope_id", value: row.scope_id }
-      ]
-    });
-    if (input.error) {
-      yield* deleteSession;
-      return yield* Effect8.fail(
-        new OAuthCompleteError({
-          message: `Authorization server returned error: ${input.error}`,
-          code: input.error
-        })
-      );
-    }
-    if (!input.code) {
-      yield* deleteSession;
-      return yield* Effect8.fail(
-        new OAuthCompleteError({
-          message: "Missing authorization code"
-        })
-      );
-    }
-    const expiresAt = Number(row.expires_at);
-    if (expiresAt <= now()) {
-      yield* deleteSession;
-      return yield* Effect8.fail(
-        new OAuthCompleteError({
-          message: "OAuth session expired"
-        })
-      );
-    }
-    const payload = decodeSessionPayload(coerceJson(row.payload));
-    const endpoint = "";
-    const connectionId = row.connection_id;
-    const tokenScope = row.token_scope;
-    const redirectUrl = row.redirect_url;
-    const exchangeResult = yield* (() => {
-      switch (payload.kind) {
-        case "dynamic-dcr":
-          return exchangeDynamicDcr(payload, input.code, redirectUrl);
-        case "authorization-code":
-          return exchangeAuthorizationCodeStrategy(
-            payload,
-            input.code,
-            redirectUrl
-          );
-      }
-    })().pipe(Effect8.tapError(() => deleteSession));
-    const connectionExpiresAt = typeof exchangeResult.tokens.expires_in === "number" ? now() + exchangeResult.tokens.expires_in * 1e3 : null;
-    const dynamicClientSecretSecretId = yield* (() => {
-      if (payload.kind !== "dynamic-dcr") return Effect8.succeed(null);
-      const clientSecret = payload.clientInformation.client_secret;
-      if (typeof clientSecret !== "string" || clientSecret.length === 0) {
-        return Effect8.succeed(null);
-      }
-      const secretId = oauthSecretId(connectionId, "client-secret");
-      return deps.secretsSet(
-        new SetSecretInput({
-          id: SecretId.make(secretId),
-          scope: ScopeId.make(tokenScope),
-          name: "OAuth Client Secret",
-          value: clientSecret
-        })
-      ).pipe(
-        Effect8.as(secretId),
-        Effect8.mapError(
-          (err) => new OAuthCompleteError({
-            message: `Failed to persist DCR client_secret: ${err instanceof Error ? err.message : String(err)}`
-          })
-        )
-      );
-    })();
-    const providerState = payload.kind === "dynamic-dcr" ? {
-      kind: "dynamic-dcr",
-      tokenEndpoint: payload.authorizationServerMetadata.token_endpoint,
-      issuerUrl: payload.authorizationServerMetadata.issuer ?? null,
-      authorizationServerUrl: payload.authorizationServerUrl,
-      authorizationServerMetadataUrl: payload.authorizationServerMetadataUrl,
-      idTokenSigningAlgValuesSupported: payload.authorizationServerMetadata.id_token_signing_alg_values_supported,
-      clientId: payload.clientInformation.client_id,
-      clientSecretSecretId: dynamicClientSecretSecretId,
-      clientAuth: payload.clientInformation.token_endpoint_auth_method === "client_secret_basic" ? "basic" : "body",
-      scopes: [...payload.scopes],
-      scope: exchangeResult.tokens.scope ?? null
-    } : {
-      kind: "authorization-code",
-      tokenEndpoint: payload.tokenEndpoint,
-      issuerUrl: payload.issuerUrl,
-      clientIdSecretId: payload.clientIdSecretId,
-      clientSecretSecretId: payload.clientSecretSecretId,
-      clientAuth: payload.clientAuth,
-      scopes: [...payload.scopes],
-      scopeSeparator: payload.scopeSeparator,
-      scope: exchangeResult.tokens.scope ?? null
-    };
-    yield* deps.connectionsCreate(
-      new CreateConnectionInput({
-        id: ConnectionId.make(connectionId),
-        scope: ScopeId.make(tokenScope),
-        provider: OAUTH2_PROVIDER_KEY,
-        identityLabel: safeHostname(
-          payload.identityLabel ?? exchangeResult.endpointForDisplay ?? endpoint
-        ),
-        accessToken: new TokenMaterial({
-          secretId: SecretId.make(oauthSecretId(connectionId, "access-token")),
-          name: "OAuth Access Token",
-          value: exchangeResult.tokens.access_token
-        }),
-        refreshToken: exchangeResult.tokens.refresh_token ? new TokenMaterial({
-          secretId: SecretId.make(oauthSecretId(connectionId, "refresh-token")),
-          name: "OAuth Refresh Token",
-          value: exchangeResult.tokens.refresh_token
-        }) : null,
-        expiresAt: connectionExpiresAt,
-        oauthScope: exchangeResult.tokens.scope ?? null,
-        providerState: Schema8.encodeSync(OAuthProviderState)(
-          providerState
-        )
-      })
-    ).pipe(
-      Effect8.mapError(
-        (err) => new OAuthCompleteError({
-          message: `Failed to mint connection: ${err instanceof Error ? err.message : String(err)}`
-        })
-      )
-    );
-    yield* deleteSession;
-    return {
-      connectionId,
-      expiresAt: connectionExpiresAt,
-      scope: exchangeResult.tokens.scope ?? null
-    };
-  });
-  const exchangeDynamicDcr = (payload, code, redirectUrl) => Effect8.gen(function* () {
-    const md = payload.authorizationServerMetadata;
-    const ci = payload.clientInformation;
-    const tokens = yield* exchangeAuthorizationCode({
-      tokenUrl: md.token_endpoint,
-      issuerUrl: md.issuer,
-      clientId: ci.client_id,
-      clientSecret: ci.client_secret ?? void 0,
-      redirectUrl,
-      codeVerifier: payload.codeVerifier,
-      code,
-      idTokenSigningAlgValuesSupported: md.id_token_signing_alg_values_supported,
-      clientAuth: ci.token_endpoint_auth_method === "client_secret_basic" ? "basic" : "body"
-    }).pipe(
-      Effect8.mapError(
-        (err) => new OAuthCompleteError({
-          message: `Token exchange failed: ${err.message}`,
-          code: err.error
-        })
-      )
-    );
-    return {
-      tokens,
-      endpointForDisplay: payload.authorizationServerUrl
-    };
-  });
-  const exchangeAuthorizationCodeStrategy = (payload, code, redirectUrl) => Effect8.gen(function* () {
-    const clientId = yield* deps.secretsGet(payload.clientIdSecretId);
-    if (clientId === null) {
-      return yield* Effect8.fail(
-        new OAuthCompleteError({
-          message: `client_id secret "${payload.clientIdSecretId}" not found`
-        })
-      );
-    }
-    const clientSecret = payload.clientSecretSecretId ? yield* deps.secretsGet(payload.clientSecretSecretId) : null;
-    if (payload.clientSecretSecretId && clientSecret === null) {
-      return yield* Effect8.fail(
-        new OAuthCompleteError({
-          message: `client_secret secret "${payload.clientSecretSecretId}" not found`
-        })
-      );
-    }
-    const tokens = yield* exchangeAuthorizationCode({
-      tokenUrl: payload.tokenEndpoint,
-      issuerUrl: payload.issuerUrl,
-      clientId,
-      clientSecret: clientSecret ?? void 0,
-      redirectUrl,
-      codeVerifier: payload.codeVerifier,
-      code,
-      clientAuth: payload.clientAuth
-    }).pipe(
-      Effect8.mapError(
-        (err) => new OAuthCompleteError({
-          message: `Token exchange failed: ${err.message}`,
-          code: err.error
-        })
-      )
-    );
-    return {
-      tokens,
-      endpointForDisplay: null
-    };
-  });
-  const cancel = (sessionId) => Effect8.gen(function* () {
-    const row = yield* deps.adapter.findOne({
-      model: "oauth2_session",
-      where: [{ field: "id", value: sessionId }]
-    });
-    if (!row) return;
-    yield* deps.adapter.delete({
-      model: "oauth2_session",
-      where: [
-        { field: "id", value: sessionId },
-        { field: "scope_id", value: row.scope_id }
-      ]
-    });
-  });
-  const connectionProvider = {
-    key: OAUTH2_PROVIDER_KEY,
-    refresh: (input) => Effect8.gen(function* () {
-      if (!input.providerState) {
-        return yield* new ConnectionRefreshError({
-          connectionId: input.connectionId,
-          message: "oauth2 connection missing providerState"
-        });
-      }
-      const state = yield* Effect8.try({
-        try: () => decodeProviderState(input.providerState),
-        catch: (cause) => new ConnectionRefreshError({
-          connectionId: input.connectionId,
-          message: `oauth2 providerState is malformed: ${cause instanceof Error ? cause.message : String(cause)}`,
-          cause
-        })
-      });
-      if (state.kind !== "client-credentials" && !input.refreshToken) {
-        return yield* new ConnectionRefreshError({
-          connectionId: input.connectionId,
-          message: "oauth2 connection has no refresh token",
-          reauthRequired: true
-        });
-      }
-      const { clientId, clientSecret } = yield* (() => {
-        switch (state.kind) {
-          case "dynamic-dcr":
-            return Effect8.gen(function* () {
-              const csec = state.clientSecretSecretId ? yield* deps.secretsGet(state.clientSecretSecretId).pipe(
-                Effect8.mapError(
-                  (cause) => new ConnectionRefreshError({
-                    connectionId: input.connectionId,
-                    message: `Failed to resolve DCR client_secret: ${cause instanceof Error ? cause.message : String(cause)}`,
-                    cause
-                  })
-                )
-              ) : null;
-              if (state.clientSecretSecretId && csec === null) {
-                return yield* new ConnectionRefreshError({
-                  connectionId: input.connectionId,
-                  message: `client_secret secret "${state.clientSecretSecretId}" not found`,
-                  reauthRequired: true
-                });
-              }
-              return { clientId: state.clientId, clientSecret: csec };
-            });
-          case "authorization-code":
-          case "client-credentials":
-            return Effect8.gen(function* () {
-              const cid = yield* deps.secretsGet(state.clientIdSecretId).pipe(
-                Effect8.mapError(
-                  (cause) => new ConnectionRefreshError({
-                    connectionId: input.connectionId,
-                    message: `Failed to resolve client_id secret: ${cause instanceof Error ? cause.message : String(cause)}`,
-                    cause
-                  })
-                )
-              );
-              if (cid === null) {
-                return yield* new ConnectionRefreshError({
-                  connectionId: input.connectionId,
-                  message: `client_id secret "${state.clientIdSecretId}" not found`,
-                  reauthRequired: true
-                });
-              }
-              const csec = state.clientSecretSecretId ? yield* deps.secretsGet(state.clientSecretSecretId).pipe(
-                Effect8.mapError(
-                  (cause) => new ConnectionRefreshError({
-                    connectionId: input.connectionId,
-                    message: `Failed to resolve client_secret: ${cause instanceof Error ? cause.message : String(cause)}`,
-                    cause
-                  })
-                )
-              ) : null;
-              if (state.clientSecretSecretId && csec === null) {
-                return yield* new ConnectionRefreshError({
-                  connectionId: input.connectionId,
-                  message: `client_secret secret "${state.clientSecretSecretId}" not found`,
-                  reauthRequired: true
-                });
-              }
-              return { clientId: cid, clientSecret: csec };
-            });
-        }
-      })();
-      const tokenEndpoint = yield* (() => {
-        if (state.tokenEndpoint) return Effect8.succeed(state.tokenEndpoint);
-        if (state.kind === "dynamic-dcr" && state.authorizationServerUrl) {
-          return discoverAuthorizationServerMetadata(
-            state.authorizationServerUrl
-          ).pipe(
-            Effect8.flatMap(
-              (metadata) => metadata?.metadata.token_endpoint ? Effect8.succeed(metadata.metadata.token_endpoint) : Effect8.fail(
-                new ConnectionRefreshError({
-                  connectionId: input.connectionId,
-                  message: "oauth2 legacy MCP providerState is missing token endpoint",
-                  reauthRequired: true
-                })
-              )
-            ),
-            Effect8.mapError(
-              (cause) => cause instanceof ConnectionRefreshError ? cause : new ConnectionRefreshError({
-                connectionId: input.connectionId,
-                message: "Failed to discover token endpoint for legacy MCP OAuth connection",
-                reauthRequired: true,
-                cause
-              })
-            )
-          );
-        }
-        return Effect8.fail(
-          new ConnectionRefreshError({
-            connectionId: input.connectionId,
-            message: "oauth2 providerState is missing token endpoint",
-            reauthRequired: true
-          })
-        );
-      })();
-      const tokens = yield* (state.kind === "client-credentials" ? exchangeClientCredentials({
-        tokenUrl: tokenEndpoint,
-        clientId,
-        clientSecret: clientSecret ?? "",
-        scopes: state.scopes,
-        scopeSeparator: state.scopeSeparator,
-        clientAuth: state.clientAuth
-      }) : refreshAccessToken({
-        tokenUrl: tokenEndpoint,
-        issuerUrl: state.kind === "dynamic-dcr" || state.kind === "authorization-code" ? state.issuerUrl ?? void 0 : void 0,
-        clientId,
-        clientSecret: clientSecret ?? void 0,
-        refreshToken: input.refreshToken,
-        scopes: state.kind === "dynamic-dcr" || state.kind === "authorization-code" ? state.scopes : void 0,
-        scopeSeparator: state.kind === "dynamic-dcr" || state.kind === "authorization-code" ? state.scopeSeparator : void 0,
-        clientAuth: state.clientAuth,
-        idTokenSigningAlgValuesSupported: state.kind === "dynamic-dcr" ? state.idTokenSigningAlgValuesSupported : void 0
-      })).pipe(
-        Effect8.mapError(
-          (err) => new ConnectionRefreshError({
-            connectionId: input.connectionId,
-            message: `OAuth refresh failed: ${err.message}`,
-            // Terminal RFC 6749 §5.2 errors mean retrying won't heal it.
-            reauthRequired: err.error ? terminalRefreshErrors.has(err.error) : false
-          })
-        )
-      );
-      const expiresAt = typeof tokens.expires_in === "number" ? now() + tokens.expires_in * 1e3 : null;
-      const result = {
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        expiresAt,
-        oauthScope: tokens.scope ?? input.oauthScope,
-        providerState: Schema8.encodeSync(OAuthProviderState)({
-          ...state,
-          tokenEndpoint,
-          scope: tokens.scope ?? state.scope
-        })
-      };
-      return result;
-    })
-  };
-  const service = { probe, start, complete, cancel };
-  return { service, connectionProvider };
-};
-var safeHostname = (value) => {
-  if (!value) return null;
-  try {
-    return new URL(value).host;
-  } catch {
-    return value;
-  }
-};
-
-// src/policies.ts
-import { Schema as Schema9 } from "effect";
-var matchPattern = (pattern, toolId) => {
-  if (pattern === "*") return true;
-  if (pattern === toolId) return true;
-  if (pattern.endsWith(".*")) {
-    const prefix = pattern.slice(0, -2);
-    if (prefix.length === 0) return false;
-    return toolId === prefix || toolId.startsWith(`${prefix}.`);
-  }
-  return false;
-};
-var isValidPattern = (pattern) => {
-  if (pattern.length === 0) return false;
-  if (pattern === "*") return true;
-  if (pattern.startsWith(".") || pattern.endsWith(".")) return false;
-  if (pattern.includes("..")) return false;
-  if (pattern.startsWith("*")) return false;
-  const segments = pattern.split(".");
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (seg.length === 0) return false;
-    if (seg.includes("*") && seg !== "*") return false;
-    if (seg === "*" && i !== segments.length - 1) return false;
-  }
-  return true;
-};
-var comparePolicyRow = (a, b) => {
-  const pa = a.position;
-  const pb = b.position;
-  if (pa < pb) return -1;
-  if (pa > pb) return 1;
-  const ia = a.id;
-  const ib = b.id;
-  return ia < ib ? -1 : ia > ib ? 1 : 0;
-};
-var resolveToolPolicy = (toolId, policies, scopeRank) => {
-  if (policies.length === 0) return void 0;
-  const sorted = [...policies].sort((a, b) => {
-    const sa = scopeRank(a);
-    const sb = scopeRank(b);
-    if (sa !== sb) return sa - sb;
-    return comparePolicyRow(a, b);
-  });
-  for (const row of sorted) {
-    if (matchPattern(row.pattern, toolId)) {
-      return {
-        action: row.action,
-        pattern: row.pattern,
-        policyId: row.id
-      };
-    }
-  }
-  return void 0;
-};
-var liftPlugin = (defaultRequiresApproval) => defaultRequiresApproval ? { action: "require_approval", source: "plugin-default" } : { action: "approve", source: "plugin-default" };
-var liftUser = (match) => ({
-  action: match.action,
-  source: "user",
-  pattern: match.pattern,
-  policyId: match.policyId
-});
-var resolveEffectivePolicy = (toolId, policies, scopeRank, defaultRequiresApproval) => {
-  const match = resolveToolPolicy(toolId, policies, scopeRank);
-  return match ? liftUser(match) : liftPlugin(defaultRequiresApproval);
-};
-var effectivePolicyFromSorted = (toolId, sortedPolicies, defaultRequiresApproval) => {
-  for (const p of sortedPolicies) {
-    if (matchPattern(p.pattern, toolId)) {
-      return {
-        action: p.action,
-        source: "user",
-        pattern: p.pattern,
-        policyId: p.id
-      };
-    }
-  }
-  return liftPlugin(defaultRequiresApproval);
-};
-var rowToToolPolicy = (row) => ({
-  id: PolicyId.make(row.id),
-  scopeId: ScopeId.make(row.scope_id),
-  pattern: row.pattern,
-  action: row.action,
-  position: row.position,
-  createdAt: row.created_at,
-  updatedAt: row.updated_at
-});
-var ToolPolicyActionSchema = Schema9.Literals([
-  "approve",
-  "require_approval",
-  "block"
-]);
-
-// src/types.ts
-import { Schema as Schema10 } from "effect";
-var ToolSchema = class extends Schema10.Class("ToolSchema")({
-  id: ToolId,
-  name: Schema10.optional(Schema10.String),
-  description: Schema10.optional(Schema10.String),
-  inputSchema: Schema10.optional(Schema10.Unknown),
-  outputSchema: Schema10.optional(Schema10.Unknown),
-  inputTypeScript: Schema10.optional(Schema10.String),
-  outputTypeScript: Schema10.optional(Schema10.String),
-  typeScriptDefinitions: Schema10.optional(
-    Schema10.Record(Schema10.String, Schema10.String)
-  )
-}) {
-};
-var SourceDetectionResult = class extends Schema10.Class(
-  "SourceDetectionResult"
-)({
-  /** Plugin id that recognized the URL (e.g. "openapi", "graphql"). */
-  kind: Schema10.String,
-  /** Confidence tier — UI uses this to pick a winner when multiple
-   *  plugins claim a URL. */
-  confidence: Schema10.Literals(["high", "medium", "low"]),
-  /** The (possibly normalized) endpoint the plugin will use. */
-  endpoint: Schema10.String,
-  /** Human-readable name suggestion, typically derived from spec title
-   *  or URL hostname. */
-  name: Schema10.String,
-  /** Namespace suggestion — the plugin's recommendation for the source
-   *  id. UI may override. */
-  namespace: Schema10.String
-}) {
-};
-
-// src/schema-types.ts
-var VALID_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-var REF_PATTERN = /^#\/(?:\$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_PATTERN)?.[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/executor.ts
-import { Context, Deferred, Effect as Effect10, Option, Result as Result2, Schema as Schema11, Semaphore } from "effect";
-import { generateKeyBetween } from "fractional-indexing";
-import {
-  StorageError as StorageError3,
-  typedAdapter
-} from "@executor-js/storage-core";
-
-// src/scoped-adapter.ts
-import { Effect as Effect9 } from "effect";
-import {
-  StorageError as StorageError2
-} from "@executor-js/storage-core";
-var SCOPE_FIELD = "scope_id";
-var collectScopedModels = (schema) => {
-  const out = /* @__PURE__ */ new Set();
-  for (const [model, def] of Object.entries(schema)) {
-    if (def.fields[SCOPE_FIELD]) out.add(model);
-  }
-  return out;
-};
-var withScopeRead = (where, ctx) => {
-  const base = (where ?? []).filter((w) => w.field !== SCOPE_FIELD);
-  const callerScope = (where ?? []).find((w) => w.field === SCOPE_FIELD);
-  if (callerScope && typeof callerScope.value === "string" && ctx.scopes.includes(callerScope.value)) {
-    return [...base, { field: SCOPE_FIELD, value: callerScope.value }];
-  }
-  const scope = ctx.scopes.length === 1 ? { field: SCOPE_FIELD, value: ctx.scopes[0] } : { field: SCOPE_FIELD, value: [...ctx.scopes], operator: "in" };
-  return [...base, scope];
-};
-var assertScopedWrite = (model, data, ctx) => {
-  const value = data[SCOPE_FIELD];
-  if (typeof value !== "string" || value.length === 0) {
-    return Effect9.fail(
-      new StorageError2({
-        message: `Write to scoped table "${model}" missing required \`scope_id\`. Callers must name the target scope explicitly.`,
-        cause: void 0
-      })
-    );
-  }
-  if (!ctx.scopes.includes(value)) {
-    return Effect9.fail(
-      new StorageError2({
-        message: `Write to scoped table "${model}" targets scope "${value}" which is not in the executor's scope stack [${ctx.scopes.join(", ")}].`,
-        cause: void 0
-      })
-    );
-  }
-  return Effect9.void;
-};
-var wrapTxMethods = (inner, ctx, scopedModels) => {
-  const isScoped = (model) => scopedModels.has(model);
-  return {
-    id: inner.id,
-    create: (data) => isScoped(data.model) ? Effect9.flatMap(
-      assertScopedWrite(
-        data.model,
-        data.data,
-        ctx
-      ),
-      () => inner.create(data)
-    ) : inner.create(data),
-    createMany: (data) => isScoped(data.model) ? Effect9.flatMap(
-      Effect9.all(
-        data.data.map(
-          (row) => assertScopedWrite(
-            data.model,
-            row,
-            ctx
-          )
-        )
-      ),
-      () => inner.createMany(data)
-    ) : inner.createMany(data),
-    findOne: (data) => isScoped(data.model) ? inner.findOne({ ...data, where: withScopeRead(data.where, ctx) }) : inner.findOne(data),
-    findMany: (data) => isScoped(data.model) ? inner.findMany({ ...data, where: withScopeRead(data.where, ctx) }) : inner.findMany(data),
-    count: (data) => isScoped(data.model) ? inner.count({ ...data, where: withScopeRead(data.where, ctx) }) : inner.count(data),
-    update: (data) => isScoped(data.model) ? Effect9.flatMap(
-      // If the caller sets `scope_id` in the update payload, it
-      // must be one of the allowed scopes. If they don't, we leave
-      // the row's existing scope_id in place — updates are scoped
-      // by the where filter's IN clause, so you can only mutate
-      // rows you can read. That's sufficient for isolation; we
-      // don't need to force-stamp on update.
-      data.update[SCOPE_FIELD] !== void 0 ? assertScopedWrite(
-        data.model,
-        data.update,
-        ctx
-      ) : Effect9.void,
-      () => inner.update({
-        ...data,
-        where: withScopeRead(data.where, ctx)
-      })
-    ) : inner.update(data),
-    updateMany: (data) => isScoped(data.model) ? Effect9.flatMap(
-      data.update[SCOPE_FIELD] !== void 0 ? assertScopedWrite(
-        data.model,
-        data.update,
-        ctx
-      ) : Effect9.void,
-      () => inner.updateMany({
-        ...data,
-        where: withScopeRead(data.where, ctx)
-      })
-    ) : inner.updateMany(data),
-    delete: (data) => isScoped(data.model) ? inner.delete({ ...data, where: withScopeRead(data.where, ctx) }) : inner.delete(data),
-    deleteMany: (data) => isScoped(data.model) ? inner.deleteMany({ ...data, where: withScopeRead(data.where, ctx) }) : inner.deleteMany(data)
-  };
-};
-var scopeAdapter = (inner, ctx, schema) => {
-  const scopedModels = collectScopedModels(schema);
-  const tx = wrapTxMethods(inner, ctx, scopedModels);
-  return {
-    ...tx,
-    transaction: (callback) => inner.transaction((rawTrx) => {
-      const scopedTrx = wrapTxMethods(
-        rawTrx,
-        ctx,
-        scopedModels
-      );
-      return callback(scopedTrx);
-    }),
-    createSchema: inner.createSchema,
-    options: inner.options
-  };
-};
-
-// src/executor.ts
-var acceptAllHandler = () => Effect10.succeed(new ElicitationResponse({ action: "accept" }));
-var resolveElicitationHandler = (onElicitation) => onElicitation === "accept-all" ? acceptAllHandler : onElicitation;
-var collectSchemas = (plugins) => {
-  const merged = { ...coreSchema };
-  for (const plugin of plugins) {
-    if (!plugin.schema) continue;
-    for (const [modelKey, model] of Object.entries(plugin.schema)) {
-      if (merged[modelKey]) {
-        throw new Error(
-          `Duplicate model "${modelKey}" contributed by plugin "${plugin.id}" (reserved by core or another plugin)`
-        );
-      }
-      merged[modelKey] = model;
-    }
-  }
-  return merged;
-};
-var rowToSource = (row) => ({
-  id: row.id,
-  scopeId: row.scope_id,
-  kind: row.kind,
-  name: row.name,
-  url: row.url ?? void 0,
-  pluginId: row.plugin_id,
-  canRemove: Boolean(row.can_remove),
-  canRefresh: Boolean(row.can_refresh),
-  canEdit: Boolean(row.can_edit),
-  runtime: false
-});
-var staticDeclToSource = (decl, pluginId) => ({
-  id: decl.id,
-  scopeId: void 0,
-  kind: decl.kind,
-  name: decl.name,
-  url: decl.url,
-  pluginId,
-  canRemove: decl.canRemove ?? false,
-  canRefresh: decl.canRefresh ?? false,
-  canEdit: decl.canEdit ?? false,
-  runtime: true
-});
-var decodeJsonColumn = (value) => {
-  if (value === null || value === void 0) return void 0;
-  if (typeof value !== "string") return value;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-};
-var rowToTool = (row, annotations) => ({
-  id: row.id,
-  sourceId: row.source_id,
-  pluginId: row.plugin_id,
-  name: row.name,
-  description: row.description,
-  inputSchema: decodeJsonColumn(row.input_schema),
-  outputSchema: decodeJsonColumn(row.output_schema),
-  annotations
-});
-var staticDeclToTool = (source, tool, pluginId) => ({
-  id: `${source.id}.${tool.name}`,
-  sourceId: source.id,
-  pluginId,
-  name: tool.name,
-  description: tool.description,
-  inputSchema: tool.inputSchema,
-  outputSchema: tool.outputSchema,
-  annotations: tool.annotations
-});
-var writeSourceInput = (core, pluginId, input) => Effect10.gen(function* () {
-  yield* deleteSourceById(core, input.id, input.scope);
-  const now = /* @__PURE__ */ new Date();
-  yield* core.create({
-    model: "source",
-    data: {
-      id: input.id,
-      scope_id: input.scope,
-      plugin_id: pluginId,
-      kind: input.kind,
-      name: input.name,
-      url: input.url ?? void 0,
-      can_remove: input.canRemove ?? true,
-      can_refresh: input.canRefresh ?? false,
-      can_edit: input.canEdit ?? false,
-      created_at: now,
-      updated_at: now
-    },
-    forceAllowId: true
-  });
-  if (input.tools.length > 0) {
-    yield* core.createMany({
-      model: "tool",
-      data: input.tools.map((tool) => ({
-        id: `${input.id}.${tool.name}`,
-        scope_id: input.scope,
-        source_id: input.id,
-        plugin_id: pluginId,
-        name: tool.name,
-        description: tool.description,
-        input_schema: tool.inputSchema ?? void 0,
-        output_schema: tool.outputSchema ?? void 0,
-        created_at: now,
-        updated_at: now
-      })),
-      forceAllowId: true
-    });
-  }
-});
-var deleteSourceById = (core, sourceId, scopeId) => Effect10.gen(function* () {
-  yield* core.deleteMany({
-    model: "tool",
-    where: [
-      { field: "source_id", value: sourceId },
-      { field: "scope_id", value: scopeId }
-    ]
-  });
-  yield* core.deleteMany({
-    model: "definition",
-    where: [
-      { field: "source_id", value: sourceId },
-      { field: "scope_id", value: scopeId }
-    ]
-  });
-  yield* core.delete({
-    model: "source",
-    where: [
-      { field: "id", value: sourceId },
-      { field: "scope_id", value: scopeId }
-    ]
-  });
-});
-var writeDefinitions = (core, pluginId, input) => Effect10.gen(function* () {
-  yield* core.deleteMany({
-    model: "definition",
-    where: [
-      { field: "source_id", value: input.sourceId },
-      { field: "scope_id", value: input.scope }
-    ]
-  });
-  const entries = Object.entries(input.definitions);
-  if (entries.length === 0) return;
-  const now = /* @__PURE__ */ new Date();
-  yield* core.createMany({
-    model: "definition",
-    data: entries.map(([name, schema]) => ({
-      id: `${input.sourceId}.${name}`,
-      scope_id: input.scope,
-      source_id: input.sourceId,
-      plugin_id: pluginId,
-      name,
-      schema,
-      created_at: now
-    })),
-    forceAllowId: true
-  });
-});
-var toolMatchesFilter = (tool, filter) => {
-  if (filter.sourceId && tool.sourceId !== filter.sourceId) return false;
-  if (filter.query) {
-    const q = filter.query.toLowerCase();
-    const hay = `${tool.name} ${tool.description}`.toLowerCase();
-    if (!hay.includes(q)) return false;
-  }
-  return true;
-};
-var activeAdapterRef = Context.Reference(
-  "executor/ActiveAdapter",
-  { defaultValue: () => null }
-);
-var buildAdapterRouter = (root) => {
-  const pick = (use) => Effect10.flatMap(
-    Effect10.service(activeAdapterRef),
-    (active) => use(active ?? root)
-  );
-  return {
-    id: root.id,
-    create: (data) => pick((a) => a.create(data)),
-    createMany: (data) => pick((a) => a.createMany(data)),
-    findOne: (data) => pick((a) => a.findOne(data)),
-    findMany: (data) => pick((a) => a.findMany(data)),
-    count: (data) => pick((a) => a.count(data)),
-    update: (data) => pick((a) => a.update(data)),
-    updateMany: (data) => pick((a) => a.updateMany(data)),
-    delete: (data) => pick((a) => a.delete(data)),
-    deleteMany: (data) => pick((a) => a.deleteMany(data)),
-    // transaction() always opens a real boundary on the ROOT adapter so the
-    // tx uses one real connection from the pool. If we're already inside a
-    // parent tx (FiberRef set), skip opening a nested sql.begin — that's
-    // the postgres.js + Hyperdrive deadlock path — and just run the
-    // callback with the existing tx handle. In both cases the callback
-    // sees a FiberRef-substituted adapter so further nested writes thread
-    // through.
-    transaction: (callback) => Effect10.flatMap(Effect10.service(activeAdapterRef), (active) => {
-      if (active) return callback(active);
-      return root.transaction(
-        (trx) => Effect10.provideService(callback(trx), activeAdapterRef, trx)
-      );
-    })
-  };
-};
-var createExecutor = (config) => Effect10.gen(function* () {
-  const defaultPlugins = () => {
-    const empty = [];
-    return empty;
-  };
-  const {
-    scopes,
-    adapter: rootAdapter,
-    blobs,
-    plugins = defaultPlugins()
-  } = config;
-  if (scopes.length === 0) {
-    return yield* Effect10.fail(
-      new Error("createExecutor requires a non-empty scopes array")
-    );
-  }
-  const schema = collectSchemas(plugins);
-  const scopeIds = scopes.map((s) => s.id);
-  const scopedRoot = scopeAdapter(
-    rootAdapter,
-    { scopes: scopeIds },
-    schema
-  );
-  const adapter = buildAdapterRouter(scopedRoot);
-  const core = typedAdapter(adapter);
-  const staticTools = /* @__PURE__ */ new Map();
-  const staticSources = /* @__PURE__ */ new Map();
-  const runtimes = /* @__PURE__ */ new Map();
-  const secretProviders = /* @__PURE__ */ new Map();
-  const connectionProviders = /* @__PURE__ */ new Map();
-  const connectionProviderAliases = /* @__PURE__ */ new Map([
-    ["mcp:oauth2", "oauth2"],
-    ["openapi:oauth2", "oauth2"],
-    ["google-discovery:google", "oauth2"],
-    ["google-discovery:oauth2", "oauth2"]
-  ]);
-  const resolveConnectionProvider = (key) => {
-    const direct = connectionProviders.get(key);
-    if (direct) return direct;
-    const canonical = connectionProviderAliases.get(key);
-    return canonical ? connectionProviders.get(canonical) : void 0;
-  };
-  const refreshInFlight = /* @__PURE__ */ new Map();
-  const refreshInFlightLock = Semaphore.makeUnsafe(1);
-  const extensions = {};
-  const scopePrecedence = /* @__PURE__ */ new Map();
-  scopeIds.forEach((s, i) => scopePrecedence.set(s, i));
-  const scopeRank = (row) => scopePrecedence.get(row.scope_id) ?? Infinity;
-  const findInnermost = (rows) => {
-    if (rows.length === 0) return null;
-    let winner;
-    let best = Infinity;
-    for (const row of rows) {
-      const rank = scopeRank(row);
-      if (rank < best) {
-        best = rank;
-        winner = row;
-      }
-    }
-    return winner ?? null;
-  };
-  const secretRowsForId = (id) => core.findMany({
-    model: "secret",
-    where: [{ field: "id", value: id }]
-  });
-  const resolveSecretValueFromRows = (id, rows) => Effect10.gen(function* () {
-    const ordered = [...rows].sort(
-      (a, b) => (scopePrecedence.get(a.scope_id) ?? Infinity) - (scopePrecedence.get(b.scope_id) ?? Infinity)
-    );
-    for (const row of ordered) {
-      const provider = secretProviders.get(row.provider);
-      if (!provider) continue;
-      const value = yield* provider.get(id, row.scope_id);
-      if (value !== null) return value;
-    }
-    const fallbackScope = scopeIds[0];
-    const candidates = [...secretProviders.values()].filter(
-      (p) => p.list
-    );
-    const values = yield* Effect10.all(
-      candidates.map(
-        (p) => p.get(id, fallbackScope).pipe(Effect10.catch(() => Effect10.succeed(null)))
-      ),
-      { concurrency: "unbounded" }
-    );
-    for (const value of values) if (value !== null) return value;
-    return null;
-  });
-  const secretsGet = (id) => Effect10.gen(function* () {
-    const rows = yield* secretRowsForId(id);
-    const owned = rows.find((row) => row.owned_by_connection_id);
-    if (owned) {
-      return yield* Effect10.fail(
-        new SecretOwnedByConnectionError({
-          secretId: SecretId.make(id),
-          connectionId: ConnectionId.make(
-            owned.owned_by_connection_id
-          )
-        })
-      );
-    }
-    return yield* resolveSecretValueFromRows(id, rows);
-  });
-  const connectionSecretGet = (id) => Effect10.gen(function* () {
-    const rows = yield* secretRowsForId(id);
-    return yield* resolveSecretValueFromRows(id, rows);
-  });
-  const secretRouteHasBackingValue = (row) => {
-    const provider = secretProviders.get(row.provider);
-    if (!provider?.has) return Effect10.succeed(true);
-    return provider.has(row.id, row.scope_id).pipe(Effect10.catch(() => Effect10.succeed(false)));
-  };
-  const secretsSet = (input) => Effect10.gen(function* () {
-    if (!scopeIds.includes(input.scope)) {
-      return yield* Effect10.fail(
-        new StorageError3({
-          message: `secrets.set targets scope "${input.scope}" which is not in the executor's scope stack [${scopeIds.join(", ")}].`,
-          cause: void 0
-        })
-      );
-    }
-    let target;
-    if (input.provider) {
-      target = secretProviders.get(input.provider);
-      if (!target) {
-        return yield* Effect10.fail(
-          new StorageError3({
-            message: `Unknown secret provider: ${input.provider}`,
-            cause: void 0
-          })
-        );
-      }
-    } else {
-      for (const provider of secretProviders.values()) {
-        if (provider.writable && provider.set) {
-          target = provider;
-          break;
-        }
-      }
-      if (!target) {
-        return yield* Effect10.fail(
-          new StorageError3({
-            message: "No writable secret providers registered",
-            cause: void 0
-          })
-        );
-      }
-    }
-    if (!target.writable || !target.set) {
-      return yield* Effect10.fail(
-        new StorageError3({
-          message: `Secret provider "${target.key}" is read-only`,
-          cause: void 0
-        })
-      );
-    }
-    yield* target.set(input.id, input.value, input.scope);
-    const now = /* @__PURE__ */ new Date();
-    yield* core.delete({
-      model: "secret",
-      where: [
-        { field: "id", value: input.id },
-        { field: "scope_id", value: input.scope }
-      ]
-    });
-    yield* core.create({
-      model: "secret",
-      data: {
-        id: input.id,
-        scope_id: input.scope,
-        name: input.name,
-        provider: target.key,
-        created_at: now
-      },
-      forceAllowId: true
-    });
-    return new SecretRef({
-      id: input.id,
-      scopeId: input.scope,
-      name: input.name,
-      provider: target.key,
-      createdAt: now
-    });
-  });
-  const secretsRemove = (id) => Effect10.gen(function* () {
-    const rows = yield* core.findMany({
-      model: "secret",
-      where: [{ field: "id", value: id }]
-    });
-    const target = findInnermost(rows);
-    if (target && target.owned_by_connection_id) {
-      return yield* Effect10.fail(
-        new SecretOwnedByConnectionError({
-          secretId: SecretId.make(id),
-          connectionId: ConnectionId.make(
-            target.owned_by_connection_id
-          )
-        })
-      );
-    }
-    const targetScope = target?.scope_id ?? scopeIds[0];
-    const deleters = [...secretProviders.values()].filter(
-      (p) => !!(p.writable && p.delete)
-    );
-    yield* Effect10.all(
-      deleters.map((p) => p.delete(id, targetScope)),
-      { concurrency: "unbounded" }
-    );
-    if (target) {
-      yield* core.delete({
-        model: "secret",
-        where: [
-          { field: "id", value: id },
-          { field: "scope_id", value: targetScope }
-        ]
-      });
-    }
-  });
-  const secretsList = () => Effect10.gen(function* () {
-    const byId = /* @__PURE__ */ new Map();
-    const allRows = yield* core.findMany({ model: "secret" });
-    const connectionOwnedIds = new Set(
-      allRows.filter((r) => r.owned_by_connection_id).map((r) => r.id)
-    );
-    const rows = allRows.filter((r) => !r.owned_by_connection_id);
-    const precedence = /* @__PURE__ */ new Map();
-    scopeIds.forEach((id, index) => precedence.set(id, index));
-    const pick = (row) => {
-      const existing = byId.get(row.id);
-      const incomingScope = row.scope_id;
-      const incomingRank = precedence.get(incomingScope) ?? Number.MAX_SAFE_INTEGER;
-      if (existing) {
-        const existingRank = precedence.get(existing.scopeId) ?? Number.MAX_SAFE_INTEGER;
-        if (existingRank <= incomingRank) return;
-      }
-      byId.set(
-        row.id,
-        new SecretRef({
-          id: SecretId.make(row.id),
-          scopeId: ScopeId.make(incomingScope),
-          name: row.name,
-          provider: row.provider,
-          createdAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at)
-        })
-      );
-    };
-    for (const row of rows) {
-      const hasBackingValue = yield* secretRouteHasBackingValue(row);
-      if (hasBackingValue) pick(row);
-    }
-    const attribution = scopes[0].id;
-    const listers = [...secretProviders.entries()].filter(
-      ([, p]) => p.list
-    );
-    const lists = yield* Effect10.all(
-      listers.map(
-        ([key, p]) => p.list().pipe(
-          Effect10.catch(() => Effect10.succeed([])),
-          Effect10.map((entries) => ({ key, entries }))
-        )
-      ),
-      { concurrency: "unbounded" }
-    );
-    for (const { key, entries } of lists) {
-      for (const entry of entries) {
-        if (byId.has(entry.id)) continue;
-        if (connectionOwnedIds.has(entry.id)) continue;
-        byId.set(
-          entry.id,
-          new SecretRef({
-            id: SecretId.make(entry.id),
-            scopeId: attribution,
-            name: entry.name,
-            provider: key,
-            createdAt: /* @__PURE__ */ new Date()
-          })
-        );
-      }
-    }
-    return Array.from(byId.values());
-  });
-  const secretsListForCtx = () => Effect10.gen(function* () {
-    const list = yield* secretsList();
-    return list.map((ref) => ({
-      id: String(ref.id),
-      name: ref.name,
-      provider: ref.provider
-    }));
-  });
-  const CONNECTION_REFRESH_SKEW_MS = 6e4;
-  const decodeProviderState2 = Schema11.decodeUnknownOption(
-    ConnectionProviderState
-  );
-  const rowToConnection = (row) => new ConnectionRef({
-    id: ConnectionId.make(row.id),
-    scopeId: ScopeId.make(row.scope_id),
-    provider: row.provider,
-    identityLabel: row.identity_label ?? null,
-    accessTokenSecretId: SecretId.make(row.access_token_secret_id),
-    refreshTokenSecretId: row.refresh_token_secret_id != null ? SecretId.make(row.refresh_token_secret_id) : null,
-    expiresAt: row.expires_at != null ? Number(row.expires_at) : null,
-    oauthScope: row.scope ?? null,
-    providerState: Option.getOrNull(
-      decodeProviderState2(decodeJsonColumn(row.provider_state))
-    ),
-    createdAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at),
-    updatedAt: row.updated_at instanceof Date ? row.updated_at : new Date(row.updated_at)
-  });
-  const findInnermostConnectionRow = (id) => Effect10.gen(function* () {
-    const rows = yield* core.findMany({
-      model: "connection",
-      where: [{ field: "id", value: id }]
-    });
-    return findInnermost(rows);
-  });
-  const connectionsGet = (id) => Effect10.gen(function* () {
-    const row = yield* findInnermostConnectionRow(id);
-    return row ? rowToConnection(row) : null;
-  });
-  const connectionsList = () => Effect10.gen(function* () {
-    const rows = yield* core.findMany({ model: "connection" });
-    const byId = /* @__PURE__ */ new Map();
-    const byIdRank = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const rank = scopeRank(row);
-      const existing = byIdRank.get(row.id);
-      if (existing === void 0 || rank < existing) {
-        byId.set(row.id, row);
-        byIdRank.set(row.id, rank);
-      }
-    }
-    return [...byId.values()].map(rowToConnection);
-  });
-  const writeOwnedSecret = (params) => Effect10.gen(function* () {
-    const target = secretProviders.get(params.provider);
-    if (!target) {
-      return yield* Effect10.fail(
-        new StorageError3({
-          message: `Unknown secret provider: ${params.provider}`,
-          cause: void 0
-        })
-      );
-    }
-    if (!target.writable || !target.set) {
-      return yield* Effect10.fail(
-        new StorageError3({
-          message: `Secret provider "${target.key}" is read-only`,
-          cause: void 0
-        })
-      );
-    }
-    yield* target.set(params.id, params.value, params.scope);
-    const now = /* @__PURE__ */ new Date();
-    yield* core.delete({
-      model: "secret",
-      where: [
-        { field: "id", value: params.id },
-        { field: "scope_id", value: params.scope }
-      ]
-    });
-    yield* core.create({
-      model: "secret",
-      data: {
-        id: params.id,
-        scope_id: params.scope,
-        name: params.name,
-        provider: target.key,
-        owned_by_connection_id: params.ownedByConnectionId,
-        created_at: now
-      },
-      forceAllowId: true
-    });
-  });
-  const pickWritableProvider = (requested) => Effect10.gen(function* () {
-    if (requested) {
-      const p = secretProviders.get(requested);
-      if (!p) {
-        return yield* Effect10.fail(
-          new StorageError3({
-            message: `Unknown secret provider: ${requested}`,
-            cause: void 0
-          })
-        );
-      }
-      return p;
-    }
-    for (const p of secretProviders.values()) {
-      if (p.writable && p.set) return p;
-    }
-    return yield* Effect10.fail(
-      new StorageError3({
-        message: "No writable secret providers registered",
-        cause: void 0
-      })
-    );
-  });
-  const connectionsCreate = (input) => Effect10.gen(function* () {
-    if (!scopeIds.includes(input.scope)) {
-      return yield* Effect10.fail(
-        new StorageError3({
-          message: `connections.create targets scope "${input.scope}" which is not in the executor's scope stack [${scopeIds.join(", ")}].`,
-          cause: void 0
-        })
-      );
-    }
-    if (!resolveConnectionProvider(input.provider)) {
-      return yield* Effect10.fail(
-        new ConnectionProviderNotRegisteredError({
-          provider: input.provider,
-          connectionId: input.id
-        })
-      );
-    }
-    const writable = yield* pickWritableProvider();
-    const now = /* @__PURE__ */ new Date();
-    return yield* adapter.transaction(
-      () => Effect10.gen(function* () {
-        yield* core.delete({
-          model: "connection",
-          where: [
-            { field: "id", value: input.id },
-            { field: "scope_id", value: input.scope }
-          ]
-        });
-        yield* writeOwnedSecret({
-          id: input.accessToken.secretId,
-          scope: input.scope,
-          name: input.accessToken.name,
-          value: input.accessToken.value,
-          provider: writable.key,
-          ownedByConnectionId: input.id
-        });
-        if (input.refreshToken) {
-          yield* writeOwnedSecret({
-            id: input.refreshToken.secretId,
-            scope: input.scope,
-            name: input.refreshToken.name,
-            value: input.refreshToken.value,
-            provider: writable.key,
-            ownedByConnectionId: input.id
-          });
-        }
-        yield* core.create({
-          model: "connection",
-          data: {
-            id: input.id,
-            scope_id: input.scope,
-            provider: input.provider,
-            identity_label: input.identityLabel ?? void 0,
-            access_token_secret_id: input.accessToken.secretId,
-            refresh_token_secret_id: input.refreshToken?.secretId ?? void 0,
-            expires_at: input.expiresAt ?? void 0,
-            scope: input.oauthScope ?? void 0,
-            provider_state: input.providerState ?? void 0,
-            created_at: now,
-            updated_at: now
-          },
-          forceAllowId: true
-        });
-        return new ConnectionRef({
-          id: input.id,
-          scopeId: input.scope,
-          provider: input.provider,
-          identityLabel: input.identityLabel,
-          accessTokenSecretId: input.accessToken.secretId,
-          refreshTokenSecretId: input.refreshToken?.secretId ?? null,
-          expiresAt: input.expiresAt,
-          oauthScope: input.oauthScope,
-          providerState: input.providerState,
-          createdAt: now,
-          updatedAt: now
-        });
-      })
-    );
-  });
-  const connectionsUpdateTokens = (input) => Effect10.gen(function* () {
-    const row = yield* findInnermostConnectionRow(input.id);
-    if (!row) {
-      return yield* Effect10.fail(
-        new ConnectionNotFoundError({ connectionId: input.id })
-      );
-    }
-    const writable = yield* pickWritableProvider();
-    const accessName = `Connection ${input.id} access token`;
-    const refreshName = `Connection ${input.id} refresh token`;
-    return yield* adapter.transaction(
-      () => Effect10.gen(function* () {
-        yield* writeOwnedSecret({
-          id: row.access_token_secret_id,
-          scope: row.scope_id,
-          name: accessName,
-          value: input.accessToken,
-          provider: writable.key,
-          ownedByConnectionId: row.id
-        });
-        const rotatedRefresh = input.refreshToken ?? void 0;
-        if (rotatedRefresh && row.refresh_token_secret_id) {
-          yield* writeOwnedSecret({
-            id: row.refresh_token_secret_id,
-            scope: row.scope_id,
-            name: refreshName,
-            value: rotatedRefresh,
-            provider: writable.key,
-            ownedByConnectionId: row.id
-          });
-        }
-        const now = /* @__PURE__ */ new Date();
-        const patch = { updated_at: now };
-        if (input.expiresAt !== void 0)
-          patch.expires_at = input.expiresAt ?? void 0;
-        if (input.oauthScope !== void 0)
-          patch.scope = input.oauthScope ?? void 0;
-        if (input.providerState !== void 0)
-          patch.provider_state = input.providerState ?? void 0;
-        if (input.identityLabel !== void 0)
-          patch.identity_label = input.identityLabel ?? void 0;
-        yield* core.update({
-          model: "connection",
-          where: [
-            { field: "id", value: row.id },
-            { field: "scope_id", value: row.scope_id }
-          ],
-          update: patch
-        });
-        const updated = yield* findInnermostConnectionRow(
-          row.id
-        );
-        if (!updated) {
-          return yield* Effect10.fail(
-            new ConnectionNotFoundError({ connectionId: input.id })
-          );
-        }
-        return rowToConnection(updated);
-      })
-    );
-  });
-  const connectionsSetIdentityLabel = (id, label) => Effect10.gen(function* () {
-    const row = yield* findInnermostConnectionRow(id);
-    if (!row) {
-      return yield* Effect10.fail(
-        new ConnectionNotFoundError({
-          connectionId: ConnectionId.make(id)
-        })
-      );
-    }
-    yield* core.update({
-      model: "connection",
-      where: [
-        { field: "id", value: id },
-        { field: "scope_id", value: row.scope_id }
-      ],
-      update: {
-        identity_label: label ?? void 0,
-        updated_at: /* @__PURE__ */ new Date()
-      }
-    });
-  });
-  const connectionsRemove = (id) => Effect10.gen(function* () {
-    const row = yield* findInnermostConnectionRow(id);
-    if (!row) return;
-    const scope = row.scope_id;
-    yield* adapter.transaction(
-      () => Effect10.gen(function* () {
-        const owned = yield* core.findMany({
-          model: "secret",
-          where: [
-            { field: "owned_by_connection_id", value: id },
-            { field: "scope_id", value: scope }
-          ]
-        });
-        const deleters = [...secretProviders.values()].filter(
-          (p) => !!(p.writable && p.delete)
-        );
-        for (const secret of owned) {
-          yield* Effect10.all(
-            deleters.map(
-              (p) => p.delete(secret.id, scope).pipe(
-                Effect10.catchCause(
-                  (cause) => Effect10.logWarning(
-                    `Failed to delete connection-owned secret from provider ${p.key}`,
-                    cause
-                  ).pipe(Effect10.as(false))
-                )
-              )
-            ),
-            { concurrency: "unbounded" }
-          );
-        }
-        yield* core.deleteMany({
-          model: "secret",
-          where: [
-            { field: "owned_by_connection_id", value: id },
-            { field: "scope_id", value: scope }
-          ]
-        });
-        yield* core.delete({
-          model: "connection",
-          where: [
-            { field: "id", value: id },
-            { field: "scope_id", value: scope }
-          ]
-        });
-      })
-    );
-  });
-  const performRefresh = (ref) => Effect10.gen(function* () {
-    const provider = resolveConnectionProvider(ref.provider);
-    if (!provider) {
-      return yield* Effect10.fail(
-        new ConnectionProviderNotRegisteredError({
-          provider: ref.provider,
-          connectionId: ref.id
-        })
-      );
-    }
-    if (!provider.refresh) {
-      return yield* Effect10.fail(
-        new ConnectionRefreshNotSupportedError({
-          connectionId: ref.id,
-          provider: ref.provider
-        })
-      );
-    }
-    const refreshTokenValue = ref.refreshTokenSecretId ? yield* connectionSecretGet(ref.refreshTokenSecretId) : null;
-    const rawResult = yield* Effect10.result(
-      provider.refresh({
-        connectionId: ref.id,
-        scopeId: ref.scopeId,
-        identityLabel: ref.identityLabel,
-        refreshToken: refreshTokenValue,
-        providerState: ref.providerState,
-        oauthScope: ref.oauthScope
-      })
-    );
-    if (Result2.isFailure(rawResult)) {
-      const err = rawResult.failure;
-      if (err.reauthRequired) {
-        return yield* Effect10.fail(
-          new ConnectionReauthRequiredError({
-            connectionId: err.connectionId,
-            provider: ref.provider,
-            message: err.message
-          })
-        );
-      }
-      return yield* Effect10.fail(err);
-    }
-    const result = rawResult.success;
-    yield* connectionsUpdateTokens({
-      id: ref.id,
-      accessToken: result.accessToken,
-      refreshToken: result.refreshToken,
-      expiresAt: result.expiresAt,
-      oauthScope: result.oauthScope,
-      providerState: result.providerState
-    });
-    return result.accessToken;
-  });
-  const connectionsAccessToken = (id) => Effect10.gen(function* () {
-    const row = yield* findInnermostConnectionRow(id);
-    if (!row) {
-      return yield* Effect10.fail(
-        new ConnectionNotFoundError({
-          connectionId: ConnectionId.make(id)
-        })
-      );
-    }
-    const ref = rowToConnection(row);
-    const now = Date.now();
-    const needsRefresh = ref.expiresAt !== null && ref.expiresAt - CONNECTION_REFRESH_SKEW_MS <= now;
-    if (!needsRefresh) {
-      const current = yield* connectionSecretGet(
-        ref.accessTokenSecretId
-      );
-      if (current !== null) return current;
-    }
-    const action = yield* refreshInFlightLock.withPermits(1)(
-      Effect10.gen(function* () {
-        const existing = refreshInFlight.get(id);
-        if (existing) {
-          return {
-            kind: "await",
-            deferred: existing
-          };
-        }
-        const deferred = yield* Deferred.make();
-        refreshInFlight.set(id, deferred);
-        return { kind: "lead", deferred };
-      })
-    );
-    if (action.kind === "await") {
-      return yield* Deferred.await(action.deferred);
-    }
-    return yield* performRefresh(ref).pipe(
-      Effect10.onExit(
-        (exit) => refreshInFlightLock.withPermits(1)(
-          Effect10.gen(function* () {
-            yield* Deferred.done(action.deferred, exit);
-            refreshInFlight.delete(id);
-          })
-        )
-      )
-    );
-  });
-  const connectionsListForCtx = () => connectionsList();
-  const oauthBundle = makeOAuth2Service({
-    adapter: core,
-    rawAdapter: adapter,
-    secretsGet: (id) => secretsGet(id).pipe(
-      Effect10.catchTag(
-        "SecretOwnedByConnectionError",
-        () => Effect10.succeed(null)
-      )
-    ),
-    secretsSet: (input) => secretsSet(input),
-    connectionsCreate: (input) => connectionsCreate(input)
-  });
-  connectionProviders.set(
-    oauthBundle.connectionProvider.key,
-    oauthBundle.connectionProvider
-  );
-  for (const plugin of plugins) {
-    if (runtimes.has(plugin.id)) {
-      return yield* Effect10.fail(
-        new Error(`Duplicate plugin id: ${plugin.id}`)
-      );
-    }
-    const storageDeps = {
-      scopes,
-      adapter: typedAdapter(adapter),
-      // Blob keys are namespaced by `<scope>/<plugin>` so two tenants
-      // sharing a backing BlobStore can't collide or leak on the
-      // same `(plugin, key)` pair. The store's `get`/`has` walk the
-      // scope stack (innermost first); `put`/`delete` require the
-      // plugin to name a target scope explicitly.
-      blobs: pluginBlobStore(blobs, scopeIds, plugin.id)
-    };
-    const storage = plugin.storage(storageDeps);
-    const ctx = {
-      scopes,
-      storage,
-      core: {
-        sources: {
-          register: (input) => Effect10.gen(function* () {
-            if (staticSources.has(input.id)) {
-              return yield* Effect10.fail(
-                new StorageError3({
-                  message: `Source id "${input.id}" collides with a static source`,
-                  cause: void 0
-                })
-              );
-            }
-            for (const tool of input.tools) {
-              const fqid = `${input.id}.${tool.name}`;
-              if (staticTools.has(fqid)) {
-                return yield* Effect10.fail(
-                  new StorageError3({
-                    message: `Tool id "${fqid}" collides with a static tool`,
-                    cause: void 0
-                  })
-                );
-              }
-            }
-            yield* adapter.transaction(
-              () => writeSourceInput(core, plugin.id, input)
-            );
-          }),
-          unregister: (sourceId) => (
-            // `unregister` is scoped to a specific source row — look up
-            // its scope before deleting so the tool/definition sweep
-            // only touches rows at that scope. Walk the full stack and
-            // pick the innermost-scope shadow so an inner-scope caller
-            // can't accidentally (via non-deterministic findOne
-            // iteration order) unregister the outer-scope source and
-            // wipe a bystander's data at the same time.
-            adapter.transaction(
-              () => Effect10.gen(function* () {
-                const rows = yield* core.findMany({
-                  model: "source",
-                  where: [{ field: "id", value: sourceId }]
-                });
-                const row = findInnermost(rows);
-                if (!row) return;
-                yield* deleteSourceById(
-                  core,
-                  sourceId,
-                  row.scope_id
-                );
-              })
-            )
-          ),
-          update: (input) => core.update({
-            model: "source",
-            where: [
-              { field: "id", value: input.id },
-              { field: "scope_id", value: input.scope }
-            ],
-            update: {
-              ...input.name !== void 0 ? { name: input.name } : {},
-              ...input.url !== void 0 ? { url: input.url ?? void 0 } : {},
-              updated_at: /* @__PURE__ */ new Date()
-            }
-          }).pipe(Effect10.asVoid)
-        },
-        definitions: {
-          register: (input) => adapter.transaction(
-            () => writeDefinitions(core, plugin.id, input)
-          )
-        }
-      },
-      secrets: {
-        get: (id) => secretsGet(id),
-        list: () => secretsListForCtx(),
-        set: (input) => secretsSet(input),
-        remove: (id) => secretsRemove(id)
-      },
-      connections: {
-        get: (id) => connectionsGet(id),
-        list: () => connectionsListForCtx(),
-        create: (input) => connectionsCreate(input),
-        updateTokens: (input) => connectionsUpdateTokens(input),
-        setIdentityLabel: (id, label) => connectionsSetIdentityLabel(id, label),
-        accessToken: (id) => connectionsAccessToken(id),
-        remove: (id) => connectionsRemove(id)
-      },
-      oauth: oauthBundle.service,
-      // Open one real tx boundary and route every nested write inside
-      // `effect` through that same handle via the activeAdapterRef —
-      // see buildAdapterRouter above. Caller-typed errors (`E`)
-      // propagate unchanged; storage failures also stay typed
-      // (`StorageFailure`) so the HTTP edge wrapper can translate them.
-      transaction: (effect) => adapter.transaction(() => effect)
-    };
-    const extension = plugin.extension ? plugin.extension(ctx) : {};
-    if (plugin.extension) {
-      extensions[plugin.id] = extension;
-    }
-    const decls = plugin.staticSources ? plugin.staticSources(extension) : [];
-    for (const source of decls) {
-      if (staticSources.has(source.id)) {
-        return yield* Effect10.fail(
-          new Error(
-            `Duplicate static source id: ${source.id} (plugin ${plugin.id})`
-          )
-        );
-      }
-      staticSources.set(source.id, { source, pluginId: plugin.id });
-      for (const tool of source.tools) {
-        const fqid = `${source.id}.${tool.name}`;
-        if (staticTools.has(fqid)) {
-          return yield* Effect10.fail(
-            new Error(
-              `Duplicate static tool id: ${fqid} (plugin ${plugin.id})`
-            )
-          );
-        }
-        staticTools.set(fqid, {
-          source,
-          tool,
-          pluginId: plugin.id,
-          ctx
-        });
-      }
-    }
-    runtimes.set(plugin.id, { plugin, storage, ctx });
-    if (plugin.secretProviders) {
-      const raw = typeof plugin.secretProviders === "function" ? plugin.secretProviders(ctx) : plugin.secretProviders;
-      const providers = Effect10.isEffect(raw) ? yield* raw : raw;
-      for (const provider of providers) {
-        if (secretProviders.has(provider.key)) {
-          return yield* Effect10.fail(
-            new Error(
-              `Duplicate secret provider key: ${provider.key} (from plugin ${plugin.id})`
-            )
-          );
-        }
-        secretProviders.set(provider.key, provider);
-      }
-    }
-    if (plugin.connectionProviders) {
-      const raw = typeof plugin.connectionProviders === "function" ? plugin.connectionProviders(ctx) : plugin.connectionProviders;
-      const providers = Effect10.isEffect(raw) ? yield* raw : raw;
-      for (const provider of providers) {
-        if (connectionProviders.has(provider.key)) {
-          return yield* Effect10.fail(
-            new Error(
-              `Duplicate connection provider key: ${provider.key} (from plugin ${plugin.id})`
-            )
-          );
-        }
-        connectionProviders.set(provider.key, provider);
-      }
-    }
-  }
-  const listSources = () => Effect10.gen(function* () {
-    const dynamic = yield* core.findMany({ model: "source" });
-    const byId = /* @__PURE__ */ new Map();
-    const byIdRank = /* @__PURE__ */ new Map();
-    for (const row of dynamic) {
-      const rank = scopeRank(row);
-      const existing = byIdRank.get(row.id);
-      if (existing === void 0 || rank < existing) {
-        byId.set(row.id, row);
-        byIdRank.set(row.id, rank);
-      }
-    }
-    const dynamicDeduped = [...byId.values()];
-    const staticList = [];
-    for (const { source, pluginId } of staticSources.values()) {
-      staticList.push(staticDeclToSource(source, pluginId));
-    }
-    const merged = [...staticList, ...dynamicDeduped.map(rowToSource)];
-    yield* Effect10.annotateCurrentSpan({
-      "executor.sources.static_count": staticList.length,
-      "executor.sources.dynamic_count": dynamicDeduped.length
-    });
-    return merged;
-  }).pipe(Effect10.withSpan("executor.sources.list"));
-  const resolveAnnotationsFor = (rows) => Effect10.gen(function* () {
-    const result = /* @__PURE__ */ new Map();
-    if (rows.length === 0) return result;
-    const groups = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const key = `${row.plugin_id}\0${row.source_id}`;
-      const bucket = groups.get(key);
-      if (bucket) bucket.push(row);
-      else groups.set(key, [row]);
-    }
-    const maps = yield* Effect10.forEach(
-      [...groups],
-      ([key, groupRows]) => Effect10.gen(function* () {
-        const [pluginId, sourceId] = key.split("\0");
-        const runtime = runtimes.get(pluginId);
-        if (!runtime?.plugin.resolveAnnotations) return void 0;
-        return yield* runtime.plugin.resolveAnnotations({
-          ctx: runtime.ctx,
-          sourceId,
-          toolRows: groupRows
-        });
-      }),
-      { concurrency: "unbounded" }
-    );
-    for (const map of maps) {
-      if (!map) continue;
-      for (const [toolId, annotations] of Object.entries(map)) {
-        result.set(toolId, annotations);
-      }
-    }
-    return result;
-  });
-  const listTools = (filter) => Effect10.gen(function* () {
-    const dynamic = yield* core.findMany({
-      model: "tool",
-      where: filter?.sourceId ? [{ field: "source_id", value: filter.sourceId }] : void 0
-    });
-    const byId = /* @__PURE__ */ new Map();
-    const byIdRank = /* @__PURE__ */ new Map();
-    for (const row of dynamic) {
-      const rank = scopeRank(row);
-      const existing = byIdRank.get(row.id);
-      if (existing === void 0 || rank < existing) {
-        byId.set(row.id, row);
-        byIdRank.set(row.id, rank);
-      }
-    }
-    const dynamicDeduped = [...byId.values()];
-    const annotations = filter?.includeAnnotations === false ? /* @__PURE__ */ new Map() : yield* resolveAnnotationsFor(dynamicDeduped).pipe(
-      Effect10.withSpan("executor.tools.list.annotations")
-    );
-    const out = [];
-    for (const entry of staticTools.values()) {
-      out.push(staticDeclToTool(entry.source, entry.tool, entry.pluginId));
-    }
-    for (const row of dynamicDeduped) {
-      out.push(rowToTool(row, annotations.get(row.id)));
-    }
-    const filtered = filter ? out.filter((t) => toolMatchesFilter(t, filter)) : out;
-    let result = filtered;
-    let blockedCount = 0;
-    if (filter?.includeBlocked !== true) {
-      const policies = yield* loadAllPolicies();
-      if (policies.length > 0) {
-        const kept = [];
-        for (const tool of filtered) {
-          const match = resolveToolPolicy(tool.id, policies, scopeRank);
-          if (match?.action === "block") {
-            blockedCount++;
-            continue;
-          }
-          kept.push(tool);
-        }
-        result = kept;
-      }
-    }
-    yield* Effect10.annotateCurrentSpan({
-      "executor.tools.static_count": staticTools.size,
-      "executor.tools.dynamic_count": dynamicDeduped.length,
-      "executor.tools.result_count": result.length,
-      "executor.tools.blocked_count": blockedCount
-    });
-    return result;
-  }).pipe(Effect10.withSpan("executor.tools.list"));
-  const loadDefinitionsForSource = (sourceId) => Effect10.gen(function* () {
-    const defRows = yield* core.findMany({
-      model: "definition",
-      where: [{ field: "source_id", value: sourceId }]
-    });
-    const winners = /* @__PURE__ */ new Map();
-    for (const row of defRows) {
-      const rank = scopeRank(row);
-      const existing = winners.get(row.name);
-      if (!existing || rank < existing.rank) {
-        winners.set(row.name, { row, rank });
-      }
-    }
-    const out = {};
-    for (const [name, { row }] of winners) out[name] = row.schema;
-    return out;
-  });
-  const buildToolSchemaView = (opts) => Effect10.gen(function* () {
-    const defs = opts.sourceId ? yield* loadDefinitionsForSource(opts.sourceId).pipe(
-      Effect10.withSpan("executor.tool.schema.load_defs")
-    ) : {};
-    const attachDefs = (schema2) => {
-      if (schema2 == null || typeof schema2 !== "object") return schema2;
-      if (Object.keys(defs).length === 0) return schema2;
-      return { ...schema2, $defs: defs };
-    };
-    const inputSchema = attachDefs(opts.rawInput);
-    const outputSchema = attachDefs(opts.rawOutput);
-    const defsMap = new Map(Object.entries(defs));
-    const preview = yield* Effect10.sync(
-      () => buildToolTypeScriptPreview({ inputSchema, outputSchema, defs: defsMap })
-    ).pipe(
-      Effect10.withSpan("schema.compile.preview", {
-        attributes: {
-          "schema.kind": "tool.preview",
-          "schema.has_input": inputSchema !== void 0,
-          "schema.has_output": outputSchema !== void 0,
-          "schema.def_count": defsMap.size
-        }
-      })
-    );
-    return new ToolSchema({
-      id: ToolId.make(opts.toolId),
-      name: opts.name,
-      description: opts.description,
-      inputSchema,
-      outputSchema,
-      inputTypeScript: preview.inputTypeScript ?? void 0,
-      outputTypeScript: preview.outputTypeScript ?? void 0,
-      typeScriptDefinitions: preview.typeScriptDefinitions ?? void 0
-    });
-  });
-  const toolSchema = (toolId) => Effect10.gen(function* () {
-    const staticEntry = staticTools.get(toolId);
-    if (staticEntry) {
-      yield* Effect10.annotateCurrentSpan({
-        "executor.tool.dispatch_path": "static",
-        "executor.source_id": staticEntry.source.id,
-        "executor.source_kind": staticEntry.source.kind
-      });
-      return yield* buildToolSchemaView({
-        toolId,
-        name: staticEntry.tool.name,
-        description: staticEntry.tool.description,
-        sourceId: void 0,
-        rawInput: staticEntry.tool.inputSchema,
-        rawOutput: staticEntry.tool.outputSchema
-      });
-    }
-    const rows = yield* core.findMany({
-      model: "tool",
-      where: [{ field: "id", value: toolId }]
-    }).pipe(Effect10.withSpan("executor.tool.resolve"));
-    const row = findInnermost(rows);
-    if (!row) return null;
-    yield* Effect10.annotateCurrentSpan({
-      "executor.tool.dispatch_path": "dynamic",
-      "executor.source_id": row.source_id,
-      "executor.plugin_id": row.plugin_id
-    });
-    return yield* buildToolSchemaView({
-      toolId,
-      name: row.name,
-      description: row.description,
-      sourceId: row.source_id,
-      rawInput: decodeJsonColumn(row.input_schema),
-      rawOutput: decodeJsonColumn(row.output_schema)
-    });
-  }).pipe(
-    Effect10.withSpan("executor.tool.schema", {
-      attributes: { "mcp.tool.name": toolId }
-    })
-  );
-  const toolsDefinitions = () => Effect10.gen(function* () {
-    const rows = yield* core.findMany({ model: "definition" });
-    const winners = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      const key = `${row.source_id}\0${row.name}`;
-      const rank = scopeRank(row);
-      const existing = winners.get(key);
-      if (!existing || rank < existing.rank) {
-        winners.set(key, { row, rank });
-      }
-    }
-    const out = {};
-    for (const { row } of winners.values()) {
-      let bucket = out[row.source_id];
-      if (!bucket) {
-        bucket = {};
-        out[row.source_id] = bucket;
-      }
-      bucket[row.name] = row.schema;
-    }
-    return out;
-  });
-  const defaultElicitationHandler = resolveElicitationHandler(
-    config.onElicitation
-  );
-  const pickHandler = (options) => options?.onElicitation ? resolveElicitationHandler(options.onElicitation) : defaultElicitationHandler;
-  const buildElicit = (toolId, args, handler) => {
-    return (request) => Effect10.gen(function* () {
-      const tid = ToolId.make(toolId);
-      const response = yield* handler({
-        toolId: tid,
-        args,
-        request
-      });
-      if (response.action !== "accept") {
-        return yield* new ElicitationDeclinedError({
-          toolId: tid,
-          action: response.action
-        });
-      }
-      return response;
-    });
-  };
-  const loadAllPolicies = () => core.findMany({ model: "tool_policy" });
-  const resolveToolPolicyForId = (toolId) => Effect10.gen(function* () {
-    const policies = yield* loadAllPolicies();
-    return resolveToolPolicy(toolId, policies, scopeRank);
-  });
-  const enforceApproval = (annotations, toolId, args, policy, handler) => Effect10.gen(function* () {
-    if (policy?.action === "approve") return;
-    const policyForcesApproval = policy?.action === "require_approval";
-    if (!policyForcesApproval && !annotations?.requiresApproval) return;
-    const tid = ToolId.make(toolId);
-    const message = annotations?.approvalDescription ? annotations.approvalDescription : policyForcesApproval && policy ? `Approve ${toolId}? (matched policy: ${policy.pattern})` : `Approve ${toolId}?`;
-    const request = new FormElicitation({
-      message,
-      requestedSchema: {}
-    });
-    const response = yield* handler({ toolId: tid, args, request });
-    if (response.action !== "accept") {
-      return yield* new ElicitationDeclinedError({
-        toolId: tid,
-        action: response.action
-      });
-    }
-  });
-  const invokeTool = (toolId, args, options) => {
-    const handler = pickHandler(options);
-    return Effect10.gen(function* () {
-      const wrapInvocationError = (effect) => effect.pipe(
-        Effect10.mapError(
-          (cause) => new ToolInvocationError({
-            toolId: ToolId.make(toolId),
-            message: cause instanceof Error ? cause.message : String(cause),
-            cause
-          })
-        )
-      );
-      const policy = yield* resolveToolPolicyForId(toolId).pipe(
-        Effect10.withSpan("executor.tool.resolve_policy")
-      );
-      if (policy?.action === "block") {
-        return yield* new ToolBlockedError({
-          toolId: ToolId.make(toolId),
-          pattern: policy.pattern
-        });
-      }
-      const staticEntry = staticTools.get(toolId);
-      if (staticEntry) {
-        yield* Effect10.annotateCurrentSpan({
-          "executor.tool.dispatch_path": "static",
-          "executor.source_id": staticEntry.source.id,
-          "executor.source_kind": staticEntry.source.kind,
-          "executor.plugin_id": staticEntry.pluginId
-        });
-        yield* enforceApproval(
-          staticEntry.tool.annotations,
-          toolId,
-          args,
-          policy,
-          handler
-        ).pipe(Effect10.withSpan("executor.tool.enforce_approval"));
-        return yield* wrapInvocationError(
-          staticEntry.tool.handler({
-            ctx: staticEntry.ctx,
-            args,
-            elicit: buildElicit(toolId, args, handler)
-          })
-        ).pipe(Effect10.withSpan("executor.tool.handler"));
-      }
-      const toolRows = yield* core.findMany({
-        model: "tool",
-        where: [{ field: "id", value: toolId }]
-      }).pipe(Effect10.withSpan("executor.tool.resolve"));
-      const row = findInnermost(toolRows);
-      if (!row) {
-        return yield* new ToolNotFoundError({
-          toolId: ToolId.make(toolId)
-        });
-      }
-      yield* Effect10.annotateCurrentSpan({
-        "executor.tool.dispatch_path": "dynamic",
-        "executor.source_id": row.source_id,
-        "executor.plugin_id": row.plugin_id
-      });
-      const runtime = runtimes.get(row.plugin_id);
-      if (!runtime) {
-        return yield* new PluginNotLoadedError({
-          pluginId: row.plugin_id,
-          toolId: ToolId.make(toolId)
-        });
-      }
-      if (!runtime.plugin.invokeTool) {
-        return yield* new NoHandlerError({
-          toolId: ToolId.make(toolId),
-          pluginId: row.plugin_id
-        });
-      }
-      let annotations;
-      if (policy?.action !== "approve" && runtime.plugin.resolveAnnotations) {
-        const map = yield* runtime.plugin.resolveAnnotations({
-          ctx: runtime.ctx,
-          sourceId: row.source_id,
-          toolRows: [row]
-        }).pipe(Effect10.withSpan("executor.tool.resolve_annotations"));
-        annotations = map[toolId];
-      }
-      yield* enforceApproval(annotations, toolId, args, policy, handler).pipe(
-        Effect10.withSpan("executor.tool.enforce_approval")
-      );
-      return yield* wrapInvocationError(
-        runtime.plugin.invokeTool({
-          ctx: runtime.ctx,
-          toolRow: row,
-          args,
-          elicit: buildElicit(toolId, args, handler)
-        })
-      ).pipe(Effect10.withSpan("executor.tool.handler"));
-    }).pipe(
-      Effect10.withSpan("executor.tool.invoke", {
-        attributes: {
-          "mcp.tool.name": toolId
-        }
-      })
-    );
-  };
-  const removeSource = (sourceId) => Effect10.gen(function* () {
-    if (staticSources.has(sourceId)) {
-      return yield* new SourceRemovalNotAllowedError({ sourceId });
-    }
-    const sourceRows = yield* core.findMany({
-      model: "source",
-      where: [{ field: "id", value: sourceId }]
-    });
-    const sourceRow = findInnermost(sourceRows);
-    if (!sourceRow) return;
-    if (!sourceRow.can_remove) {
-      return yield* new SourceRemovalNotAllowedError({ sourceId });
-    }
-    const runtime = runtimes.get(sourceRow.plugin_id);
-    yield* adapter.transaction(
-      () => Effect10.gen(function* () {
-        if (runtime?.plugin.removeSource) {
-          yield* runtime.plugin.removeSource({
-            ctx: runtime.ctx,
-            sourceId,
-            scope: sourceRow.scope_id
-          });
-        }
-        yield* deleteSourceById(
-          core,
-          sourceId,
-          sourceRow.scope_id
-        );
-      })
-    );
-  });
-  const refreshSource = (sourceId) => Effect10.gen(function* () {
-    if (staticSources.has(sourceId)) return;
-    const sourceRows = yield* core.findMany({
-      model: "source",
-      where: [{ field: "id", value: sourceId }]
-    });
-    const sourceRow = findInnermost(sourceRows);
-    if (!sourceRow) return;
-    const runtime = runtimes.get(sourceRow.plugin_id);
-    if (runtime?.plugin.refreshSource) {
-      yield* runtime.plugin.refreshSource({
-        ctx: runtime.ctx,
-        sourceId,
-        scope: sourceRow.scope_id
-      });
-    }
-  });
-  const detectionConfidenceScore = (confidence) => {
-    switch (confidence) {
-      case "high":
-        return 3;
-      case "medium":
-        return 2;
-      case "low":
-        return 1;
-    }
-  };
-  const detectSource = (url) => Effect10.gen(function* () {
-    const results = [];
-    for (const runtime of runtimes.values()) {
-      if (!runtime.plugin.detect) continue;
-      const result = yield* runtime.plugin.detect({ ctx: runtime.ctx, url }).pipe(Effect10.catch(() => Effect10.succeed(null)));
-      if (result) results.push(result);
-    }
-    return results.sort(
-      (a, b) => detectionConfidenceScore(b.confidence) - detectionConfidenceScore(a.confidence)
-    );
-  });
-  const sourceDefinitions = (sourceId) => loadDefinitionsForSource(sourceId);
-  const secretsStatus = (id) => Effect10.gen(function* () {
-    const rows = yield* secretRowsForId(id);
-    if (rows.some((row) => row.owned_by_connection_id)) return "missing";
-    for (const row of rows) {
-      if (yield* secretRouteHasBackingValue(row)) return "resolved";
-    }
-    for (const provider of secretProviders.values()) {
-      if (!provider.list) continue;
-      const entries = yield* provider.list().pipe(Effect10.catch(() => Effect10.succeed([])));
-      if (entries.some((e) => e.id === id)) return "resolved";
-    }
-    return "missing";
-  });
-  const policiesList = () => Effect10.gen(function* () {
-    const rows = yield* loadAllPolicies();
-    const sorted = [...rows].sort((a, b) => {
-      const sa = scopeRank(a);
-      const sb = scopeRank(b);
-      if (sa !== sb) return sa - sb;
-      return comparePolicyRow(a, b);
-    });
-    return sorted.map((row) => rowToToolPolicy(row));
-  }).pipe(Effect10.withSpan("executor.policies.list"));
-  const policiesCreate = (input) => Effect10.gen(function* () {
-    if (!isValidPattern(input.pattern)) {
-      return yield* new StorageError3({
-        message: `Invalid tool policy pattern "${input.pattern}". Patterns must be "*" (every tool), an exact tool id ("a.b.c"), or a trailing wildcard ("a.b.*"). Leading "*" prefixes ("*foo", "*.foo") and "**" are not supported.`,
-        cause: void 0
-      });
-    }
-    if (!isToolPolicyAction(input.action)) {
-      return yield* new StorageError3({
-        message: `Invalid tool policy action "${String(input.action)}". Expected "approve" | "require_approval" | "block".`,
-        cause: void 0
-      });
-    }
-    let position = input.position;
-    if (position === void 0) {
-      const existing = yield* core.findMany({
-        model: "tool_policy",
-        where: [{ field: "scope_id", value: input.scope }]
-      });
-      let min = null;
-      for (const row of existing) {
-        const p = row.position;
-        if (min === null || p < min) min = p;
-      }
-      position = generateKeyBetween(null, min);
-    }
-    const id = `pol_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
-    const now = /* @__PURE__ */ new Date();
-    yield* core.create({
-      model: "tool_policy",
-      data: {
-        id,
-        scope_id: input.scope,
-        pattern: input.pattern,
-        action: input.action,
-        position,
-        created_at: now,
-        updated_at: now
-      },
-      forceAllowId: true
-    });
-    return rowToToolPolicy({
-      id,
-      scope_id: input.scope,
-      pattern: input.pattern,
-      action: input.action,
-      position,
-      created_at: now,
-      updated_at: now
-    });
-  }).pipe(Effect10.withSpan("executor.policies.create"));
-  const policiesUpdate = (input) => Effect10.gen(function* () {
-    if (input.pattern !== void 0 && !isValidPattern(input.pattern)) {
-      return yield* new StorageError3({
-        message: `Invalid tool policy pattern "${input.pattern}".`,
-        cause: void 0
-      });
-    }
-    if (input.action !== void 0 && !isToolPolicyAction(input.action)) {
-      return yield* new StorageError3({
-        message: `Invalid tool policy action "${String(input.action)}".`,
-        cause: void 0
-      });
-    }
-    const rows = yield* core.findMany({
-      model: "tool_policy",
-      where: [{ field: "id", value: input.id }]
-    });
-    const row = findInnermost(rows);
-    if (!row) {
-      return yield* new StorageError3({
-        message: `Tool policy "${input.id}" not found.`,
-        cause: void 0
-      });
-    }
-    const updated = {
-      ...row,
-      pattern: input.pattern ?? row.pattern,
-      action: input.action ?? row.action,
-      position: input.position ?? row.position,
-      updated_at: /* @__PURE__ */ new Date()
-    };
-    yield* core.update({
-      model: "tool_policy",
-      where: [
-        { field: "id", value: input.id },
-        { field: "scope_id", value: row.scope_id }
-      ],
-      update: {
-        pattern: updated.pattern,
-        action: updated.action,
-        position: updated.position,
-        updated_at: updated.updated_at
-      }
-    });
-    return rowToToolPolicy(updated);
-  }).pipe(Effect10.withSpan("executor.policies.update"));
-  const policiesRemove = (id) => core.deleteMany({
-    model: "tool_policy",
-    where: [{ field: "id", value: id }]
-  }).pipe(Effect10.asVoid, Effect10.withSpan("executor.policies.remove"));
-  const policiesResolve = (toolId) => resolveToolPolicyForId(toolId).pipe(
-    Effect10.withSpan("executor.policies.resolve")
-  );
-  const close = () => Effect10.gen(function* () {
-    for (const runtime of runtimes.values()) {
-      if (runtime.plugin.close) {
-        yield* runtime.plugin.close();
-      }
-    }
-  });
-  const base = {
-    scopes,
-    tools: {
-      list: listTools,
-      schema: toolSchema,
-      definitions: toolsDefinitions,
-      invoke: invokeTool
-    },
-    sources: {
-      list: listSources,
-      remove: removeSource,
-      refresh: refreshSource,
-      detect: detectSource,
-      definitions: sourceDefinitions
-    },
-    secrets: {
-      get: secretsGet,
-      status: secretsStatus,
-      set: secretsSet,
-      remove: secretsRemove,
-      list: secretsList,
-      providers: () => Effect10.sync(
-        () => Array.from(secretProviders.keys())
-      )
-    },
-    connections: {
-      get: connectionsGet,
-      list: connectionsList,
-      create: connectionsCreate,
-      updateTokens: connectionsUpdateTokens,
-      setIdentityLabel: connectionsSetIdentityLabel,
-      accessToken: connectionsAccessToken,
-      remove: connectionsRemove,
-      providers: () => Effect10.sync(
-        () => Array.from(connectionProviders.keys())
-      )
-    },
-    oauth: oauthBundle.service,
-    policies: {
-      list: policiesList,
-      create: policiesCreate,
-      update: policiesUpdate,
-      remove: policiesRemove,
-      resolve: policiesResolve
-    },
-    close
-  };
-  const toExecutor = (value) => value;
-  return toExecutor(Object.assign(base, extensions));
-});
-
-// src/scope.ts
-import { Schema as Schema12 } from "effect";
-var Scope = class extends Schema12.Class("Scope")({
-  id: ScopeId,
-  name: Schema12.String,
-  createdAt: Schema12.Date
-}) {
-};
-
-// src/secret-backed-value.ts
-import { Effect as Effect11, Schema as Schema13 } from "effect";
-var SecretBackedValue = Schema13.Union([
-  Schema13.String,
-  Schema13.Struct({
-    secretId: Schema13.String,
-    prefix: Schema13.optional(Schema13.String)
-  })
-]);
-var SecretBackedMap = Schema13.Record(Schema13.String, SecretBackedValue);
-var isSecretBackedRef = (value) => typeof value !== "string";
-var resolveSecretBackedMap = ({
-  values,
-  getSecret,
-  onMissing,
-  onError,
-  missing = "fail"
-}) => {
-  const entries = Object.entries(values ?? {});
-  if (entries.length === 0) return Effect11.succeed(void 0);
-  return Effect11.gen(function* () {
-    const resolved = {};
-    for (const [name, value] of entries) {
-      if (typeof value === "string") {
-        resolved[name] = value;
-        continue;
-      }
-      const secret = yield* getSecret(value.secretId).pipe(
-        Effect11.mapError((error) => onError?.(error, name, value) ?? error)
-      );
-      if (secret === null) {
-        if (missing === "drop") continue;
-        return yield* Effect11.fail(onMissing(name, value));
-      }
-      resolved[name] = value.prefix ? `${value.prefix}${secret}` : secret;
-    }
-    return Object.keys(resolved).length > 0 ? resolved : void 0;
-  });
-};
-
-// src/config.ts
-var defineExecutorConfig = (config) => config;
-
-export {
-  pluginBlobStore,
-  makeInMemoryBlobStore,
-  ScopeId,
-  ToolId,
-  SecretId,
-  PolicyId,
-  ConnectionId,
-  ConnectionProviderState,
-  ConnectionRef,
-  TokenMaterial,
-  CreateConnectionInput,
-  ConnectionRefreshError,
-  UpdateConnectionTokensInput,
-  coreSchema,
-  TOOL_POLICY_ACTIONS,
-  isToolPolicyAction,
-  FormElicitation,
-  UrlElicitation,
-  ElicitationAction,
-  ElicitationResponse,
-  ElicitationDeclinedError,
-  ToolNotFoundError,
-  ToolInvocationError,
-  PluginNotLoadedError,
-  NoHandlerError,
-  ToolBlockedError,
-  SourceNotFoundError,
-  SourceRemovalNotAllowedError,
-  SecretNotFoundError,
-  SecretResolutionError,
-  SecretOwnedByConnectionError,
-  ConnectionNotFoundError,
-  ConnectionProviderNotRegisteredError,
-  ConnectionRefreshNotSupportedError,
-  ConnectionReauthRequiredError,
-  SecretRef,
-  SetSecretInput,
-  OAuthDynamicDcrStrategy,
-  OAuthAuthorizationCodeStrategy,
-  OAuthClientCredentialsStrategy,
-  OAuthStrategy,
-  OAuthProviderState,
-  OAUTH2_PROVIDER_KEY,
-  OAuthProbeError,
-  OAuthStartError,
-  OAuthCompleteError,
-  OAuthSessionNotFoundError,
-  OAUTH2_SESSION_TTL_MS,
-  OAuth2Error,
-  OAUTH2_REFRESH_SKEW_MS,
-  OAUTH2_DEFAULT_TIMEOUT_MS,
-  createPkceCodeVerifier,
-  createPkceCodeChallenge,
-  buildAuthorizationUrl,
-  exchangeAuthorizationCode,
-  exchangeClientCredentials,
-  refreshAccessToken,
-  shouldRefreshToken,
-  OAuthDiscoveryError,
-  OAuthProtectedResourceMetadataSchema,
-  OAuthAuthorizationServerMetadataSchema,
-  OAuthClientInformationSchema,
-  discoverProtectedResourceMetadata,
-  discoverAuthorizationServerMetadata,
-  registerDynamicClient,
-  beginDynamicAuthorization,
-  makeOAuth2Service,
-  matchPattern,
-  isValidPattern,
-  resolveToolPolicy,
-  resolveEffectivePolicy,
-  effectivePolicyFromSorted,
-  rowToToolPolicy,
-  ToolPolicyActionSchema,
-  ToolSchema,
-  SourceDetectionResult,
-  schemaToTypeScriptPreview,
-  schemaToTypeScriptPreviewWithDefs,
-  buildToolTypeScriptPreview,
-  collectSchemas,
-  createExecutor,
-  Scope,
-  SecretBackedValue,
-  SecretBackedMap,
-  isSecretBackedRef,
-  resolveSecretBackedMap,
-  defineExecutorConfig
-};
-//# sourceMappingURL=chunk-2WV7VSNL.js.map