@assemblyline-agents/runtime 5.0.9 → 6.0.0

package/dist/connections.js

@@ -1,178 +1,52 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
-import { ConnectionAuthorizationFailedError, ConnectionAuthorizationRequiredError, isConnectionAuthorizationFailedError, isConnectionAuthorizationRequiredError, resolveSandboxPath, shellQuote } from "@assemblyline-agents/core";
-import { OAUTH_STANDARD_TOKEN_FIELDS, buildOAuthChallenge, connectionPrincipalFor, connectionPrincipalKey, grantToTokenResult, isTokenExpired, normalizeAuthorization, randomUrlToken, resolveHeadersDefinition, storedGrantExpired, tokenCacheKey } from "./connection-auth-util.js";
-import { HttpApiConnectionClient, A2AConnectionClient, CredentialConnectionClient, McpConnectionClient, OpenApiConnectionClient, RelayMcpConnectionClient, SdkApiConnectionClient, readResponseBody } from "./connection-clients.js";
-import { SandboxCliConnectionClient } from "./sandbox-cli-client.js";
 import { audienceAllowsConnectionAccess } from "./audience.js";
-import { InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore } from "./connection-stores.js";
-import { connectionToolAccess, connectionToolApproval, isLiveConnection, isRecord, liveDefinitionUrl, parseQualifiedName, scoreMatch, stringValue, timestamp, tokenize } from "./connection-util.js";
-import { CredentialBroker } from "./credential-broker.js";
+import { ConnectionAuthorizationService } from "./connection-authorization-service.js";
+import { connectionPrincipalFor, connectionPrincipalKey, normalizeAuthorization } from "./connection-auth-util.js";
+import { A2AConnectionClient, CredentialConnectionClient, HttpApiConnectionClient, McpConnectionClient, OpenApiConnectionClient, RelayMcpConnectionClient, SdkApiConnectionClient } from "./connection-clients.js";
+import { materializeCredentialsWithContext } from "./connection-credential-materialization.js";
+import { loadResolvedConnection } from "./connection-definition-loader.js";
+import { searchConnections } from "./connection-discovery.js";
+import { CONNECTION_PAIR_TOOL_NAME, ConnectionConfigurationError } from "./connection-runtime-types.js";
+import { connectionToolAccess, connectionToolApproval, isLiveConnection, isRecord, liveDefinitionUrl, parseQualifiedName } from "./connection-util.js";
+import { SandboxCliConnectionClient } from "./sandbox-cli-client.js";
 import { CredentialTransferConnectionClient } from "./credential-transfer-client.js";
-import { createConnectionAssetApi } from "./connection-assets.js";
 export * from "./connection-auth-util.js";
 export * from "./connection-clients.js";
+export * from "./connection-credential-materialization.js";
+export * from "./connection-runtime-types.js";
 export * from "./connection-stores.js";
 export * from "./connection-util.js";
 export * from "./computer-relay-protocol.js";
-export class ConnectionConfigurationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ConnectionConfigurationError";
-    }
-}
-export function isConnectionConfigurationError(error) {
-    return error instanceof ConnectionConfigurationError;
-}
-const MATERIALIZED_CREDENTIAL_ROOT = "/workspace/.assembly-line/credentials/";
-// Compose the channel-visible response for a run parked on connection
-// authorization. The generic "authorization required" string is useless to the
-// human — the challenge URL is the thing they need to click.
-export async function connectionAuthorizationPrompt(store, authorizationSessionId, baseResponse) {
-    const session = authorizationSessionId ? await store.getSession(authorizationSessionId) : undefined;
-    const url = session && typeof session.challenge.url === "string" ? session.challenge.url : undefined;
-    if (!url)
-        return baseResponse || "Connection authorization required.";
-    const prompt = `Authorization required for ${session?.connectionName ?? "a connection"} — approve here: ${url}`;
-    return baseResponse ? `${baseResponse}\n\n${prompt}` : prompt;
-}
-/**
- * Project declared connection credentials into a freshly acquired sandbox.
- * Tokens resolve host-side (cached grant or refresh exchange — the grant
- * store is updated before anything reaches the sandbox), so recycling the
- * sandbox never loses a durable credential and never holds one. Subagent
- * sandboxes are excluded: they receive only their engine harness credential,
- * never the parent's connections. The emitted event carries paths only —
- * credential contents never reach the event log.
- */
-export async function materializeConnectionCredentialsIntoSandbox(run, registry, sandbox, appendEvent) {
-    if (run.input.channel === "subagent" || typeof run.input.parentRunId === "string")
-        return;
-    const { materialized, pending } = await registry.materializeCredentials({
-        id: run.id,
-        input: run.input
-    });
-    if (materialized.length === 0 && pending.length === 0)
-        return;
-    for (const credential of materialized) {
-        for (const file of credential.files) {
-            assertMaterializedCredentialPath(credential.connection, file.path);
-            await sandbox.writeFile(file.path, file.content);
-            const physicalPath = resolveSandboxPath(sandbox.root, file.path);
-            await sandbox.shell(`chmod ${file.mode.toString(8)} -- ${shellQuote(physicalPath)}`);
-        }
-        for (const command of credential.commands ?? []) {
-            await sandbox.shell(command);
-        }
-    }
-    await appendEvent("connections.credentials_materialized", {
-        materialized: materialized.map((credential) => ({
-            connection: credential.connection,
-            files: credential.files.map((file) => file.path),
-            ...(credential.audit ? { audit: credential.audit } : {})
-        })),
-        pending
-    });
-}
-function assertMaterializedCredentialPath(connectionName, path) {
-    const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
-    if (normalized.split("/").includes("..") || !normalized.startsWith(MATERIALIZED_CREDENTIAL_ROOT)) {
-        throw new ConnectionConfigurationError(`Connection ${connectionName} materialize files must be under ${MATERIALIZED_CREDENTIAL_ROOT}`);
-    }
-}
-function assertRedactedAuditMetadata(connectionName, audit) {
-    const visit = (value, path) => {
-        if (Array.isArray(value)) {
-            value.forEach((item, index) => visit(item, `${path}[${index}]`));
-            return;
-        }
-        if (!value || typeof value !== "object")
-            return;
-        for (const [key, item] of Object.entries(value)) {
-            if (/(?:token|secret|password|authorization|credential)/iu.test(key)) {
-                throw new ConnectionConfigurationError(`Connection ${connectionName} audit metadata contains forbidden secret-like key ${path}.${key}.`);
-            }
-            visit(item, `${path}.${key}`);
-        }
-    };
-    visit(audit, "audit");
-}
-export const CONNECTION_PAIR_TOOL_NAME = "pair";
-// The synthetic host-side pairing tool advertised for connections that define
-// redeemPairingCode. The input field is named `secret` so tool-call event
-// logging redacts the pasted one-time code automatically.
-function pairingToolItem(connection) {
-    return {
-        connection: connection.name,
-        qualifiedName: `${connection.name}__${CONNECTION_PAIR_TOOL_NAME}`,
-        tool: CONNECTION_PAIR_TOOL_NAME,
-        description: `Pair ${connection.name} by redeeming a one-time pairing packet or claim code. When the user pastes binding/pairing instructions for ${connection.name}, call this with the FULL pasted text as \`secret\`; the host exchanges it and stores the credential durably. Only call this for a supplied packet; the tool's presence does not mean an existing grant is missing.`,
-        inputSchema: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                secret: {
-                    type: "string",
-                    description: "The full pasted pairing packet, binding instructions, or one-time claim code."
-                }
-            },
-            required: ["secret"]
-        }
-    };
-}
-const CREDENTIAL_TEMPLATE_PATTERN = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*)\s*\}\}/gu;
-function templateUsesToken(template) {
-    return [...template.matchAll(CREDENTIAL_TEMPLATE_PATTERN)].some((match) => match[1] === "token");
-}
-// An unrendered placeholder in a credentials file is a silent misconfiguration
-// (the CLI reads garbage), so unknown keys fail loudly instead of passing through.
-function renderCredentialTemplate(template, values, connectionName) {
-    return template.replace(CREDENTIAL_TEMPLATE_PATTERN, (_match, key) => {
-        const value = values[key];
-        if (value === undefined) {
-            throw new Error(`Connection ${connectionName} materialize template references unknown placeholder {{${key}}}.`);
-        }
-        return value;
-    });
-}
+export * from "./credential-broker.js";
+export * from "./credential-transfer-client.js";
+/** Registry for discovery, execution, credential materialization, and authorization. */
 export class RuntimeConnectionRegistry {
     options;
     resolved = new Map();
     clients = new Map();
-    tokenCache = new Map();
-    executionContext = new AsyncLocalStorage();
-    authorizationIntent = new AsyncLocalStorage();
-    pendingAuthorizationCreations = new Map();
-    grantStore;
-    authorizationSessionStore;
-    credentialBroker;
+    authorization;
     constructor(options) {
         this.options = options;
-        this.grantStore = options.grantStore ?? options.credentialBroker?.grantStore ?? new InMemoryConnectionGrantStore();
-        this.credentialBroker = options.credentialBroker ?? new CredentialBroker({
-            store: { resolve: async () => undefined },
-            grantStore: this.grantStore
-        });
-        this.authorizationSessionStore = options.authorizationSessionStore ?? new InMemoryConnectionAuthorizationSessionStore();
+        this.authorization = new ConnectionAuthorizationService(options, (connection, session) => this.resolveConnection(connection, session));
+    }
+    pluginRuntimePaths(connectionName) {
+        return this.options.pluginRuntime?.[connectionName];
     }
     hasLiveConnections() {
         return this.options.connections.some(isLiveConnection);
     }
     liveConnectionNames() {
-        return this.options.connections
-            .filter(isLiveConnection)
-            .map((connection) => connection.name);
+        return this.options.connections.filter(isLiveConnection).map((connection) => connection.name);
     }
-    /** Resolve the host-only event adapter without exposing it as a model tool. */
     async eventBindingContext(connectionName) {
         const compiled = this.options.connections.find((connection) => connection.name === connectionName);
         if (!compiled || !isLiveConnection(compiled)) {
             throw new ConnectionConfigurationError(`Connection ${connectionName} is not registered as a live connection.`);
         }
         const definition = (await this.resolveConnection(compiled)).definition;
-        if (!definition.events)
+        if (!definition.events) {
             throw new ConnectionConfigurationError(`Connection ${connectionName} does not accept provider events.`);
-        const context = this.resolverContext(compiled);
+        }
+        const context = this.authorization.resolverContext(compiled);
         let principal;
         if (definition.events.scope === "connection") {
             principal = { type: "app" };
@@ -199,99 +73,26 @@ export class RuntimeConnectionRegistry {
             config: context.config,
             credentials: context.credentials,
             getToken: async () => {
-                if (!definition.auth)
+                if (!definition.auth) {
                     throw new ConnectionConfigurationError(`Connection ${connectionName} event adapter requested a token without connection auth.`);
-                return this.resolveToken(compiled, definition.auth, context, liveDefinitionUrl(definition));
+                }
+                return this.authorization.resolveToken(compiled, definition.auth, context, liveDefinitionUrl(definition));
             }
         };
     }
     async search(input, execution) {
-        return this.authorizationIntent.run("discover", () => this.withExecutionContext(execution, () => this.searchWithContext(input)));
-    }
-    async searchWithContext(input) {
-        const keywords = input.keywords ?? "";
-        const limit = input.limit ?? 10;
-        const target = this.targetConnections(input.connection);
-        const queryTokens = tokenize(keywords);
-        const scored = [];
-        const failures = [];
-        const privateOnly = [];
-        // Pairing tools surface even when the connection cannot authenticate yet —
-        // redeeming a pasted packet is exactly how an unauthorized connection
-        // becomes authorized, so it must not hide behind the failure path.
-        const pairable = [];
-        for (const connection of target) {
-            // A personal connection stays registered in a shared run, but its tool
-            // catalog, pairing, and authorization state are private-surface only.
-            if (!this.connectionAccessible(connection)) {
-                privateOnly.push({
-                    connection: connection.name,
-                    description: `${connection.name} is registered. Its personal tools, pairing, and authorization status are available only on a private surface such as a direct message; this does not mean a durable grant is missing.`,
-                    requiresPrivateAudience: true
-                });
-                continue;
-            }
-            let metadata;
-            try {
-                if (await this.supportsPairing(connection)) {
-                    pairable.push(pairingToolItem(connection));
-                }
-                metadata = await this.getClient(connection.name).getToolMetadata();
-            }
-            catch (error) {
-                failures.push(this.connectionFailure(connection, error));
-                continue;
-            }
-            for (const tool of metadata) {
-                const score = keywords.trim() ? scoreMatch(queryTokens, tool) : 1;
-                if (score <= 0)
-                    continue;
-                const item = {
-                    connection: tool.connection,
-                    description: tool.description,
-                    inputSchema: tool.inputSchema,
-                    qualifiedName: tool.qualifiedName,
-                    tool: tool.name
-                };
-                if (tool.outputSchema)
-                    item.outputSchema = tool.outputSchema;
-                scored.push({
-                    score,
-                    item
-                });
-            }
-        }
-        scored.sort((a, b) => b.score - a.score);
-        const matches = scored.slice(0, limit).map((entry) => entry.item);
-        if (matches.length > 0)
-            return [...pairable, ...matches, ...privateOnly, ...failures];
-        const privateConnectionNames = new Set(privateOnly.map((item) => item.connection));
-        return [
-            ...pairable,
-            ...privateOnly,
-            ...target.map((connection) => ({
-                connection: connection.name,
-                description: connection.description ?? `${connection.name} connection`
-            })).filter((item) => !privateConnectionNames.has(item.connection)),
-            ...failures
-        ];
+        return this.authorization.runWithIntent("discover", () => this.authorization.withExecutionContext(execution, () => searchConnections(input, {
+            targetConnections: (name) => this.targetConnections(name),
+            connectionAccessible: (connection) => this.connectionAccessible(connection),
+            supportsPairing: (connection) => this.supportsPairing(connection),
+            toolMetadata: async (connectionName) => this.getClient(connectionName).getToolMetadata()
+        })));
     }
-    // Deliberately does not swallow load errors: a definition module that fails
-    // to resolve (for example a deployed artifact missing the connection's
-    // package) must surface the real cause instead of silently hiding the
-    // pairing tool that would otherwise be the recovery path.
     async supportsPairing(connection) {
         return typeof (await this.resolveConnection(connection)).definition.redeemPairingCode === "function";
     }
-    /**
-     * Report which live connections can redeem a pairing code right now, and
-     * which cannot because their definition failed to resolve (missing package,
-     * unset env, platform mismatch). Backs the core `pair` tool: a connection
-     * that cannot even load must still be *diagnosable* from the model — the
-     * resolve failure is the answer the user needs, not a hidden tool.
-     */
     async pairingStatus() {
-        return this.authorizationIntent.run("discover", async () => {
+        return this.authorization.runWithIntent("discover", async () => {
             const pairable = [];
             const unavailable = [];
             for (const connection of this.options.connections) {
@@ -311,11 +112,6 @@ export class RuntimeConnectionRegistry {
             return { pairable, unavailable };
         });
     }
-    /**
-     * Redeem a user-provided one-time pairing code host-side and persist the
-     * resulting credentials in the grant store. The durable credential never
-     * enters a sandbox; the model only relays the single-use code.
-     */
     async redeemPairingCode(connectionName, code) {
         const compiled = this.options.connections.find((connection) => connection.name === connectionName);
         if (!compiled || !isLiveConnection(compiled)) {
@@ -330,15 +126,14 @@ export class RuntimeConnectionRegistry {
             throw new Error(`Connection ${connectionName} does not support pairing codes.`);
         if (!code.trim())
             throw new Error("A pairing code is required.");
-        const context = this.resolverContext(compiled);
+        const context = this.authorization.resolverContext(compiled);
         const token = await redeem({ code }, context);
         const authorization = definition.auth
             ? await normalizeAuthorization(definition.auth, context)
             : { kind: "token", principalType: "user", getToken: async () => token };
         const principal = connectionPrincipalFor(compiled, authorization, context);
         const principalKey = connectionPrincipalKey(principal);
-        await this.saveGrantFromToken(compiled.name, principal, principalKey, token);
-        this.tokenCache.delete(tokenCacheKey(compiled.name, principal));
+        await this.authorization.storeToken(compiled, principal, principalKey, token);
         return {
             connected: true,
             connection: compiled.name,
@@ -346,7 +141,7 @@ export class RuntimeConnectionRegistry {
         };
     }
     async metadataForQualifiedName(qualifiedName) {
-        return this.authorizationIntent.run("discover", async () => {
+        return this.authorization.runWithIntent("discover", async () => {
             const parsed = parseQualifiedName(qualifiedName);
             if (!parsed)
                 return undefined;
@@ -365,16 +160,11 @@ export class RuntimeConnectionRegistry {
         if (!compiled || !this.toolAllowed(compiled)) {
             throw new Error(`Connection tool ${qualifiedName} is unavailable here: personal connections work only on a private surface such as a direct message.`);
         }
-        // "<connection>__pair" is the synthetic host-side pairing tool; it must
-        // run before any client/auth resolution (the whole point is that the
-        // connection is not authorized yet).
-        if (parsed.toolName === CONNECTION_PAIR_TOOL_NAME) {
-            if (compiled && await this.supportsPairing(compiled)) {
-                const secret = isRecord(input) && typeof input.secret === "string" ? input.secret : "";
-                return this.withExecutionContext(execution, () => this.redeemPairingCode(parsed.connectionName, secret));
-            }
+        if (parsed.toolName === CONNECTION_PAIR_TOOL_NAME && await this.supportsPairing(compiled)) {
+            const secret = isRecord(input) && typeof input.secret === "string" ? input.secret : "";
+            return this.authorization.withExecutionContext(execution, () => this.redeemPairingCode(parsed.connectionName, secret));
         }
-        return this.withExecutionContext(execution, () => this.getClient(parsed.connectionName).executeTool(parsed.toolName, input));
+        return this.authorization.withExecutionContext(execution, () => this.getClient(parsed.connectionName).executeTool(parsed.toolName, input));
     }
     async getConnectionApproval(connectionName, toolName) {
         const compiled = this.options.connections.find((connection) => connection.name === connectionName);
@@ -383,10 +173,6 @@ export class RuntimeConnectionRegistry {
         if (!this.toolAllowed(compiled)) {
             throw new Error(`Connection tool ${connectionName}__${toolName} is unavailable here: personal connections work only on a private surface such as a direct message.`);
         }
-        // Pairing is a synthetic host-side bootstrap operation, not a provider
-        // tool. It must bypass the provider connection's ordinary read/write
-        // classification or discovery will advertise a tool that execution then
-        // rejects before the redeemer can run.
         if (toolName === CONNECTION_PAIR_TOOL_NAME) {
             if (!await this.supportsPairing(compiled)) {
                 throw new Error(`Connection ${connectionName} does not support pairing codes.`);
@@ -432,6 +218,12 @@ export class RuntimeConnectionRegistry {
         this.clients.set(connectionName, client);
         return client;
     }
+    async executeSandboxCli(invocation) {
+        if (!this.options.executeSandboxCli) {
+            throw new Error("Sandbox CLI connection execution requires an active agent run sandbox.");
+        }
+        return this.options.executeSandboxCli(invocation, this.authorization.currentExecutionContext());
+    }
     async transferCredential(input) {
         const source = this.options.connections.find((connection) => connection.name === input.sourceConnection);
         const sink = this.options.connections.find((connection) => connection.name === input.sinkConnection);
@@ -444,8 +236,8 @@ export class RuntimeConnectionRegistry {
         const sinkCapability = "credentialSink" in sinkDefinition ? sinkDefinition.credentialSink : undefined;
         if (!sourceCapability || !sinkCapability)
             throw new Error("Credential transfer source or sink is not configured.");
-        const principal = this.connectionPrincipal(sink);
-        const execution = this.executionContext.getStore();
+        const principal = this.authorization.connectionPrincipal(sink);
+        const execution = this.authorization.currentExecutionContext();
         const runId = execution?.runId ?? this.options.runId;
         const identity = {
             principal,
@@ -462,7 +254,7 @@ export class RuntimeConnectionRegistry {
         try {
             const value = await sourceCapability.resolve(input.reference, context);
             await sinkCapability.consume(value, input.target, context);
-            await this.credentialBroker.recordTransfer({
+            await this.authorization.credentialBroker.recordTransfer({
                 credential: input.reference,
                 connection: sink.name,
                 identity,
@@ -472,7 +264,7 @@ export class RuntimeConnectionRegistry {
             return { status: "filled" };
         }
         catch {
-            await this.credentialBroker.recordTransfer({
+            await this.authorization.credentialBroker.recordTransfer({
                 credential: input.reference,
                 connection: sink.name,
                 identity,
@@ -482,303 +274,31 @@ export class RuntimeConnectionRegistry {
             throw new Error(`Credential transfer from ${source.name} to ${sink.name} failed.`);
         }
     }
-    async executeSandboxCli(invocation) {
-        if (!this.options.executeSandboxCli) {
-            throw new Error("Sandbox CLI connection execution requires an active agent run sandbox.");
-        }
-        return this.options.executeSandboxCli(invocation, this.executionContext.getStore());
-    }
     async resolveHeaders(connection, definition) {
-        const headers = {};
-        const context = this.resolverContext(connection);
-        if (definition.auth !== undefined) {
-            const token = await this.resolveToken(connection, definition.auth, context, liveDefinitionUrl(definition));
-            const tokenType = token.tokenType?.trim() || "Bearer";
-            headers.Authorization = `${tokenType} ${token.token}`;
-        }
-        if (definition.headers !== undefined) {
-            const resolved = await resolveHeadersDefinition(definition.headers, context);
-            for (const [key, value] of Object.entries(resolved)) {
-                if (key.toLowerCase() === "authorization" && headers.Authorization !== undefined) {
-                    throw new Error(`Connection ${connection.name} headers must not include Authorization when auth is configured.`);
-                }
-                headers[key] = value;
-            }
-        }
-        return headers;
+        return this.authorization.resolveHeaders(connection, definition);
     }
-    /**
-     * Start (or resume) the authorization flow for a named connection and
-     * report where to send the user's browser. Backs the host's authenticated
-     * GET /assembly-line/connections/authorize endpoint (agent-control route class,
-     * JSON — deliberately not a public 302, so unauthenticated callers cannot
-     * trigger consent flows or enumerate connection names): the dashboard
-     * fetches the URL and opens it; the provider redirects back to the public,
-     * idempotency-claimed callback. Hitting it when a grant already exists
-     * reports "connected" instead of minting a redundant session; a pending
-     * session's challenge is reused.
-     */
     async beginAuthorization(connectionName) {
-        return this.authorizationIntent.run("authorize", () => this.beginAuthorizationWithContext(connectionName));
+        return this.authorization.beginAuthorization(connectionName);
     }
-    async beginAuthorizationWithContext(connectionName) {
-        const compiled = this.options.connections.find((connection) => connection.name === connectionName);
-        if (!compiled || !isLiveConnection(compiled))
-            return { status: "unavailable", reason: "unknown_connection" };
-        let definition;
-        try {
-            definition = (await this.resolveConnection(compiled)).definition;
-        }
-        catch (error) {
-            return { status: "unavailable", reason: error instanceof Error ? error.message : String(error) };
-        }
-        if (!definition.auth)
-            return { status: "unavailable", reason: "connection_has_no_auth" };
-        try {
-            await this.resolveToken(compiled, definition.auth, this.resolverContext(compiled), liveDefinitionUrl(definition));
-            return { status: "connected" };
-        }
-        catch (error) {
-            if (isConnectionAuthorizationRequiredError(error)) {
-                const url = typeof error.challenge?.url === "string" ? error.challenge.url : undefined;
-                return url ? { status: "authorize", url } : { status: "unavailable", reason: error.reason };
-            }
-            return { status: "unavailable", reason: error instanceof Error ? error.message : String(error) };
-        }
-    }
-    /**
-     * Resolve every connection that declares `materialize` and render its
-     * credential files for injection into the agent sandbox. Tokens resolve
-     * through the normal host-side flow — cached grant, or a refresh exchange
-     * that persists the rotated grant to the grant store BEFORE anything is
-     * rendered — so the sandbox only ever sees the short-lived access token.
-     *
-     * A connection that cannot resolve is reported as pending unless the run
-     * explicitly requested that credential. Explicit requests fail closed so a
-     * run can never continue after a missing, revoked, or mismatched credential
-     * it declared as required. Merely making a credential connection available
-     * to the agent must not prevent unrelated sandbox work.
-     */
     async materializeCredentials(run) {
-        return this.authorizationIntent.run("discover", () => this.materializeCredentialsWithContext(run));
-    }
-    async materializeCredentialsWithContext(run) {
-        const materialized = [];
-        const pending = [];
-        for (const compiled of this.options.connections) {
-            if (!this.toolAllowed(compiled))
-                continue;
-            const credentialRequested = sandboxCredentialWasRequested(run, compiled.name);
-            // Credential-file connections are leases, not ambient sandbox setup.
-            // Merely configuring one on a root agent must never resolve or project
-            // its secret into an unrelated sandbox acquisition.
-            if (compiled.protocol === "credential" && !credentialRequested)
-                continue;
-            const failClosed = compiled.protocol === "credential" && credentialRequested;
-            let context;
-            let definition;
-            try {
-                context = this.resolverContext(compiled);
-                definition = (await this.resolveConnection(compiled)).definition;
-            }
-            catch (error) {
-                if (failClosed)
-                    throw error;
-                pending.push({ connection: compiled.name, reason: error instanceof Error ? error.message : String(error) });
-                continue;
-            }
-            const spec = definition.materialize;
-            if (!spec || ((spec.files?.length ?? 0) === 0 && !spec.resolve))
-                continue;
-            const staticFiles = spec.files ?? [];
-            const needsToken = staticFiles.some((file) => templateUsesToken(file.path) || templateUsesToken(file.content));
-            let resolvedToken = { token: "" };
-            if (needsToken) {
-                if (!definition.auth) {
-                    pending.push({ connection: compiled.name, reason: "materialize templates use {{token}} but the connection has no auth" });
-                    continue;
-                }
-                try {
-                    resolvedToken = await this.resolveToken(compiled, definition.auth, context, liveDefinitionUrl(definition));
-                }
-                catch (error) {
-                    if (failClosed)
-                        throw error;
-                    if (isConnectionAuthorizationRequiredError(error)) {
-                        const authorizeUrl = typeof error.challenge?.url === "string" ? error.challenge.url : undefined;
-                        pending.push({ connection: compiled.name, reason: `authorization_required: ${error.reason}`, ...(authorizeUrl ? { authorizeUrl } : {}) });
-                        continue;
-                    }
-                    const reason = isConnectionAuthorizationFailedError(error)
-                        ? `${error.reason}: ${error.message}`
-                        : error instanceof Error
-                            ? error.message
-                            : String(error);
-                    pending.push({ connection: compiled.name, reason });
-                    continue;
-                }
-            }
-            let files = staticFiles;
-            let commands = [];
-            let audit;
-            if (spec.resolve) {
-                if (!run) {
-                    pending.push({ connection: compiled.name, reason: "run_context_required" });
-                    continue;
-                }
-                let lazyToken;
-                try {
-                    const authorization = definition.auth
-                        ? await normalizeAuthorization(definition.auth, context)
-                        : undefined;
-                    const principal = authorization
-                        ? connectionPrincipalFor(compiled, authorization, context)
-                        : { type: "app" };
-                    const resolved = await spec.resolve({
-                        connectionName: compiled.name,
-                        agentId: this.options.agentId ?? "",
-                        run,
-                        principal,
-                        session: context.session,
-                        config: context.config,
-                        credentials: context.credentials,
-                        fetch: this.options.fetch,
-                        getToken: async () => {
-                            if (!definition.auth)
-                                throw new Error(`Connection ${compiled.name} materialization requested a token without auth.`);
-                            lazyToken ??= this.resolveToken(compiled, definition.auth, context, liveDefinitionUrl(definition));
-                            return lazyToken;
-                        }
-                    });
-                    if (!resolved)
-                        continue;
-                    files = resolved.files;
-                    commands = resolved.commands ?? [];
-                    audit = resolved.audit;
-                    if (audit)
-                        assertRedactedAuditMetadata(compiled.name, audit);
-                }
-                catch (error) {
-                    if (failClosed)
-                        throw error;
-                    if (isConnectionAuthorizationRequiredError(error)) {
-                        const authorizeUrl = typeof error.challenge?.url === "string" ? error.challenge.url : undefined;
-                        pending.push({ connection: compiled.name, reason: `authorization_required: ${error.reason}`, ...(authorizeUrl ? { authorizeUrl } : {}) });
-                        continue;
-                    }
-                    const reason = isConnectionAuthorizationFailedError(error)
-                        ? `${error.reason}: ${error.message}`
-                        : error instanceof Error
-                            ? error.message
-                            : String(error);
-                    pending.push({ connection: compiled.name, reason });
-                    continue;
-                }
-            }
-            const values = { token: resolvedToken.token };
-            // Extra token-response fields (captured into the grant's credential bag)
-            // are addressable as {{credential.<key>}} — e.g. a provider-issued user
-            // or account id a sandbox-side CLI needs to build API paths.
-            for (const [key, value] of Object.entries(resolvedToken.credential ?? {})) {
-                if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-                    values[`credential.${key}`] = String(value);
-                }
-            }
-            try {
-                materialized.push({
-                    connection: compiled.name,
-                    files: files.map((file) => ({
-                        path: renderCredentialTemplate(file.path, values, compiled.name),
-                        content: renderCredentialTemplate(file.content, values, compiled.name),
-                        mode: file.mode ?? 0o600
-                    })),
-                    ...(commands.length > 0 ? { commands } : {}),
-                    ...(audit ? { audit } : {})
-                });
-            }
-            catch (error) {
-                if (failClosed)
-                    throw error;
-                pending.push({ connection: compiled.name, reason: error instanceof Error ? error.message : String(error) });
-            }
-        }
-        return { materialized, pending };
+        return this.authorization.runWithIntent("discover", () => materializeCredentialsWithContext(this.options, run, {
+            toolAllowed: (connection) => this.toolAllowed(connection),
+            resolveConnection: (connection) => this.resolveConnection(connection),
+            resolveToken: (connection, auth, context, resolvedUrl) => this.authorization.resolveToken(connection, auth, context, resolvedUrl),
+            resolverContext: (connection) => this.authorization.resolverContext(connection)
+        }));
     }
     async evictToken(connection, definition) {
-        if (!definition.auth)
-            return;
-        const context = this.resolverContext(connection);
-        const authorization = await normalizeAuthorization(definition.auth, context);
-        const principal = connectionPrincipalFor(connection, authorization, context);
-        const cacheKey = tokenCacheKey(connection.name, principal);
-        const principalKey = connectionPrincipalKey(principal);
-        const cached = this.tokenCache.get(cacheKey);
-        this.tokenCache.delete(cacheKey);
-        if (cached?.authorization.kind === "oauth" || authorization.kind === "oauth") {
-            await this.grantStore.deleteGrant(connection.name, principalKey);
-        }
-        await (cached?.authorization ?? authorization).evict?.({ principal, connection: { url: connection.url ?? "" } });
+        return this.authorization.evictToken(connection, definition);
     }
     async completeAuthorization(callback) {
-        const state = callback.params.state;
-        if (!state)
-            throw new ConnectionAuthorizationFailedError("unknown", { reason: "missing_state", retryable: false });
-        const session = await this.authorizationSessionStore.getSessionByState(state);
-        if (!session)
-            throw new ConnectionAuthorizationFailedError("unknown", { reason: "unknown_state", retryable: false });
-        // Provider callbacks are routinely retried. Once the grant was saved and
-        // the session completed, return the durable result without attempting to
-        // exchange the one-time authorization code again.
-        if (session.status === "completed")
-            return session;
-        if (session.expiresAt <= Date.now()) {
-            await this.authorizationSessionStore.updateSession(session.id, { status: "expired" });
-            throw new ConnectionAuthorizationFailedError(session.connectionName, { reason: "authorization_expired", retryable: true });
-        }
-        if (callback.params.error) {
-            await this.authorizationSessionStore.updateSession(session.id, { status: "denied" });
-            throw new ConnectionAuthorizationFailedError(session.connectionName, {
-                reason: callback.params.error,
-                retryable: true,
-                message: callback.params.error_description ?? `Connection ${session.connectionName} authorization was denied.`
-            });
-        }
-        const compiled = this.options.connections.find((connection) => connection.name === session.connectionName);
-        if (!compiled || !isLiveConnection(compiled)) {
-            throw new ConnectionAuthorizationFailedError(session.connectionName, { reason: "connection_not_found", retryable: false });
-        }
-        const resolved = await this.resolveConnection(compiled);
-        if (!resolved.definition.auth) {
-            throw new ConnectionAuthorizationFailedError(session.connectionName, { reason: "auth_not_configured", retryable: false });
-        }
-        const authorization = await normalizeAuthorization(resolved.definition.auth, this.resolverContext(compiled, session.session));
-        const connectionContext = { url: compiled.url ?? "" };
-        let token;
-        if (authorization.kind === "oauth" && authorization.oauth) {
-            token = await this.exchangeOAuthAuthorizationCode(authorization.oauth, session, callback);
-        }
-        else if (authorization.completeAuthorization) {
-            const completeOptions = {
-                principal: session.principal,
-                connection: connectionContext,
-                callbackUrl: session.callbackUrl,
-                callback
-            };
-            if (session.resume !== undefined)
-                completeOptions.resume = session.resume;
-            token = await authorization.completeAuthorization(completeOptions);
-        }
-        else {
-            throw new ConnectionAuthorizationFailedError(session.connectionName, { reason: "callback_not_supported", retryable: false });
-        }
-        await this.saveGrantFromToken(compiled.name, session.principal, session.principalKey, token);
-        return this.authorizationSessionStore.updateSession(session.id, { status: "completed" });
+        return this.authorization.completeAuthorization(callback);
     }
     async getAuthorizationSession(id) {
-        return this.authorizationSessionStore.getSession(id);
+        return this.authorization.getAuthorizationSession(id);
     }
     async updateAuthorizationSession(id, patch) {
-        return this.authorizationSessionStore.updateSession(id, patch);
+        return this.authorization.updateAuthorizationSession(id, patch);
     }
     async close() {
         await Promise.allSettled([...this.clients.values()].map((client) => client.close()));
@@ -788,7 +308,7 @@ export class RuntimeConnectionRegistry {
         return this.options.fetch(input, init);
     }
     async processEnvironment(connection) {
-        const context = this.factoryContext(connection);
+        const context = this.authorization.factoryContext(connection);
         const environment = {};
         for (const name of connection.requiredConfig ?? []) {
             const value = context.config[name];
@@ -818,493 +338,27 @@ export class RuntimeConnectionRegistry {
         return environment;
     }
     async credentialValue(connection, name, purpose) {
-        return this.factoryContext(connection).credentials.get(name, { purpose, delivery: "relay" });
+        return this.authorization.factoryContext(connection).credentials.get(name, { purpose, delivery: "relay" });
     }
-    async resolveConnection(compiled) {
+    async resolveConnection(compiled, session) {
+        if (session) {
+            return loadResolvedConnection(this.options, compiled, this.authorization.factoryContext(compiled, session));
+        }
         const existing = this.resolved.get(compiled.name);
         if (existing)
             return existing;
-        const promise = this.loadResolvedConnection(compiled);
+        const promise = loadResolvedConnection(this.options, compiled, this.authorization.factoryContext(compiled));
         this.resolved.set(compiled.name, promise);
         return promise;
     }
-    async loadResolvedConnection(compiled) {
-        const platform = this.options.platform ?? process.platform;
-        if (compiled.hostRequirements?.platforms?.length && !compiled.hostRequirements.platforms.includes(platform)) {
-            throw new Error(`${compiled.hostRequirements.message} Current runtime platform: ${platform}.`);
-        }
-        const loaded = await this.options.loadDefinition(compiled);
-        const factoryContext = this.factoryContext(compiled);
-        const dynamic = compiled.source.path.startsWith("dynamic://");
-        const raw = !dynamic && isConnectionFactory(loaded)
-            ? await loaded.create(factoryContext)
-            : loaded;
-        if (!isRecord(raw))
-            throw new Error(`Connection ${compiled.name} did not export an object.`);
-        if (compiled.protocol === "mcp") {
-            if (raw.transport === "stdio") {
-                if (compiled.source.path.startsWith("dynamic://")) {
-                    throw new Error(`Dynamic MCP connection ${compiled.name} cannot launch a stdio process.`);
-                }
-                if (typeof raw.command !== "string" || !raw.command.trim()) {
-                    throw new Error(`Stdio MCP connection ${compiled.name} must export command.`);
-                }
-                if (raw.args !== undefined && (!Array.isArray(raw.args) || raw.args.some((argument) => typeof argument !== "string"))) {
-                    throw new Error(`Stdio MCP connection ${compiled.name} args must contain only strings.`);
-                }
-            }
-            else if (raw.transport === "relay") {
-                if (compiled.source.path.startsWith("dynamic://")) {
-                    throw new Error(`Dynamic MCP connection ${compiled.name} cannot use a device relay.`);
-                }
-                if (typeof raw.url !== "string" || typeof raw.credential !== "string") {
-                    throw new Error(`Relay MCP connection ${compiled.name} must export url and credential.`);
-                }
-            }
-            else if (typeof raw.url !== "string") {
-                throw new Error(`HTTP MCP connection ${compiled.name} must export url.`);
-            }
-            if (typeof raw.description !== "string")
-                throw new Error(`MCP connection ${compiled.name} must export description.`);
-            return { compiled, definition: raw };
-        }
-        if (compiled.protocol === "openapi") {
-            if (raw.spec === undefined)
-                throw new Error(`OpenAPI connection ${compiled.name} must export spec.`);
-            if (typeof raw.description !== "string")
-                throw new Error(`OpenAPI connection ${compiled.name} must export description.`);
-            return { compiled, definition: raw };
-        }
-        if (compiled.protocol === "a2a") {
-            if (typeof raw.agentCardUrl !== "string")
-                throw new Error(`A2A connection ${compiled.name} must export agentCardUrl.`);
-            if (typeof raw.description !== "string")
-                throw new Error(`A2A connection ${compiled.name} must export description.`);
-            if (!raw.access || typeof raw.access !== "object")
-                throw new Error(`A2A connection ${compiled.name} must export access.`);
-            return { compiled, definition: raw };
-        }
-        if (compiled.protocol === "http") {
-            if (typeof raw.baseUrl !== "string")
-                throw new Error(`HTTP API connection ${compiled.name} must export baseUrl.`);
-            if (typeof raw.description !== "string")
-                throw new Error(`HTTP API connection ${compiled.name} must export description.`);
-            if (!Array.isArray(raw.operations))
-                throw new Error(`HTTP API connection ${compiled.name} must export operations.`);
-            return { compiled, definition: raw };
-        }
-        if (compiled.protocol === "sdk") {
-            if (compiled.source.path.startsWith("dynamic://")) {
-                throw new Error(`Dynamic SDK API connection ${compiled.name} is not allowed.`);
-            }
-            if (typeof raw.description !== "string" || !Array.isArray(raw.operations) || typeof raw.execute !== "function") {
-                throw new Error(`SDK API connection ${compiled.name} must export description, operations, and execute.`);
-            }
-            if (!raw.access || typeof raw.access !== "object") {
-                throw new Error(`SDK API connection ${compiled.name} must export access.`);
-            }
-            return { compiled, definition: raw };
-        }
-        if (compiled.protocol === "cli") {
-            if (compiled.source.path.startsWith("dynamic://")) {
-                throw new Error(`Dynamic CLI connection ${compiled.name} is not allowed.`);
-            }
-            if (raw.transport !== "sandbox" || typeof raw.command !== "string" || !raw.command.trim()) {
-                throw new Error(`Sandbox CLI connection ${compiled.name} must export transport "sandbox" and command.`);
-            }
-            if (typeof raw.description !== "string" || !Array.isArray(raw.tools)) {
-                throw new Error(`Sandbox CLI connection ${compiled.name} must export description and tools.`);
-            }
-            return { compiled, definition: raw };
-        }
-        if (compiled.protocol === "credential") {
-            if (typeof raw.description !== "string" || !raw.auth || !raw.materialize || typeof raw.materialize !== "object") {
-                throw new Error(`Credential connection ${compiled.name} must export description, auth, and materialize.`);
-            }
-            return { compiled, definition: raw };
-        }
-        throw new Error(`Connection ${compiled.name} is declaration-only.`);
-    }
     targetConnections(name) {
-        return this.options.connections.filter((connection) => {
-            if (!isLiveConnection(connection))
-                return false;
-            return !name || connection.name === name;
-        });
+        return this.options.connections.filter((connection) => isLiveConnection(connection) && (!name || connection.name === name));
     }
-    /**
-     * The single audience rule: personal (user-subject) connections exist only
-     * on private surfaces. Everything else — discovery, execution, pairing,
-     * and credential materialization — derives from this one predicate.
-     */
     connectionAccessible(connection) {
-        const audience = this.options.audience ?? { private: true };
-        return audienceAllowsConnectionAccess(audience, connection.subject);
+        return audienceAllowsConnectionAccess(this.options.audience ?? { private: true }, connection.subject);
     }
     toolAllowed(connection) {
         return isLiveConnection(connection) && this.connectionAccessible(connection);
     }
-    connectionFailure(connection, error) {
-        if (isConnectionAuthorizationRequiredError(error)) {
-            return {
-                connection: connection.name,
-                description: connection.description ?? `${connection.name} connection`,
-                needsAuthorization: true,
-                error: error.reason
-            };
-        }
-        if (isConnectionAuthorizationFailedError(error)) {
-            return {
-                connection: connection.name,
-                description: connection.description ?? `${connection.name} connection`,
-                error: `${error.reason}: ${error.message}`
-            };
-        }
-        return {
-            connection: connection.name,
-            description: connection.description ?? `${connection.name} connection`,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-    async resolveToken(connection, auth, context, resolvedUrl) {
-        const authorization = await normalizeAuthorization(auth, context);
-        const principal = connectionPrincipalFor(connection, authorization, context);
-        const principalKey = connectionPrincipalKey(principal);
-        const cacheKey = tokenCacheKey(connection.name, principal);
-        const cached = this.tokenCache.get(cacheKey);
-        if (cached && !isTokenExpired(cached.token))
-            return cached.token;
-        const connectionContext = { url: resolvedUrl ?? connection.url ?? "" };
-        if (authorization.kind === "oauth" || authorization.kind === "interactive") {
-            const stored = await this.grantStore.getGrant(connection.name, principalKey);
-            if (stored && !storedGrantExpired(stored)) {
-                const token = grantToTokenResult(stored);
-                this.tokenCache.set(cacheKey, { token, authorization, principal, connection: connectionContext });
-                return token;
-            }
-            if (stored?.refreshToken && authorization.kind === "oauth" && authorization.oauth) {
-                const refreshed = await this.refreshOAuthGrant(authorization.oauth, connection.name, principal, principalKey, stored.refreshToken);
-                // saveGrantFromToken preserved the credential bag on the grant; mirror
-                // that on the returned token so template rendering sees it too.
-                if (!refreshed.credential && stored.credential)
-                    refreshed.credential = stored.credential;
-                this.tokenCache.set(cacheKey, { token: refreshed, authorization, principal, connection: connectionContext });
-                return refreshed;
-            }
-            if (authorization.kind === "oauth") {
-                throw await this.createAuthorizationRequiredError(connection, authorization, principal, principalKey, context, connectionContext);
-            }
-        }
-        try {
-            const token = await authorization.getToken({ principal, connection: connectionContext });
-            this.tokenCache.set(cacheKey, { token, authorization, principal, connection: connectionContext });
-            return token;
-        }
-        catch (error) {
-            if (isConnectionAuthorizationRequiredError(error) && authorization.kind === "interactive") {
-                if (this.authorizationIntent.getStore() === "discover") {
-                    throw this.authorizationRequiredWithoutSession(connection, error);
-                }
-                throw await this.createAuthorizationRequiredError(connection, authorization, principal, principalKey, context, connectionContext, error);
-            }
-            if (isConnectionAuthorizationRequiredError(error) || isConnectionAuthorizationFailedError(error))
-                throw error;
-            throw error;
-        }
-    }
-    resolverContext(connection, session = this.options.session) {
-        const factory = this.factoryContext(connection, session);
-        return {
-            config: factory.config,
-            credentials: factory.credentials,
-            fetch: this.options.fetch,
-            session
-        };
-    }
-    factoryContext(connection, session = this.options.session) {
-        const principal = this.connectionPrincipal(connection, session);
-        const audience = this.options.audience ?? { private: true };
-        const identity = () => {
-            const runId = this.executionContext.getStore()?.runId ?? this.options.runId;
-            return { principal, audience, ...(runId ? { runId } : {}) };
-        };
-        const configNames = [...(connection.requiredConfig ?? []), ...(connection.optionalConfig ?? [])];
-        return {
-            connectionName: connection.name,
-            agentId: this.options.agentId ?? "",
-            principal,
-            audience,
-            config: Object.freeze(Object.fromEntries(configNames.map((name) => [name, this.options.config?.[name]]))),
-            credentials: this.credentialBroker.scoped(connection, identity),
-            ...(this.options.blob && (this.executionContext.getStore()?.runId ?? this.options.runId) ? {
-                assets: createConnectionAssetApi({
-                    blob: this.options.blob,
-                    runId: (this.executionContext.getStore()?.runId ?? this.options.runId),
-                    sourceConnection: connection.name
-                })
-            } : {}),
-            fetch: this.options.fetch,
-            session
-        };
-    }
-    connectionPrincipal(connection, session = this.options.session) {
-        if (connection.subject !== "user")
-            return { type: "app" };
-        if (session.principal?.type === "user")
-            return session.principal;
-        if (session.userId) {
-            return {
-                type: "user",
-                id: session.userId,
-                issuer: session.channel ?? "assembly-line"
-            };
-        }
-        throw new ConnectionConfigurationError(`Connection ${connection.name} requires an authenticated user principal.`);
-    }
-    async withExecutionContext(execution, fn) {
-        return execution ? this.executionContext.run(execution, fn) : fn();
-    }
-    async createAuthorizationRequiredError(connection, authorization, principal, principalKey, context, connectionContext, cause) {
-        if (this.authorizationIntent.getStore() === "discover") {
-            return this.authorizationRequiredWithoutSession(connection, cause);
-        }
-        const key = `${connection.name}\0${principalKey}`;
-        const pending = this.pendingAuthorizationCreations.get(key);
-        if (pending)
-            return pending;
-        const creation = this.createAuthorizationRequiredErrorWithContext(connection, authorization, principal, principalKey, context, connectionContext, cause);
-        this.pendingAuthorizationCreations.set(key, creation);
-        try {
-            return await creation;
-        }
-        finally {
-            if (this.pendingAuthorizationCreations.get(key) === creation) {
-                this.pendingAuthorizationCreations.delete(key);
-            }
-        }
-    }
-    authorizationRequiredWithoutSession(connection, cause) {
-        const options = {
-            reason: cause?.reason ?? "authorization_required"
-        };
-        if (cause?.message)
-            options.message = cause.message;
-        if (cause?.challenge)
-            options.challenge = cause.challenge;
-        return new ConnectionAuthorizationRequiredError(connection.name, options);
-    }
-    async createAuthorizationRequiredErrorWithContext(connection, authorization, principal, principalKey, context, connectionContext, cause) {
-        await this.authorizationSessionStore.deleteExpiredSessions?.(Date.now());
-        const existing = await this.authorizationSessionStore.findPendingSession(connection.name, principalKey);
-        if (existing) {
-            const options = {
-                reason: cause?.reason ?? "authorization_required",
-                challenge: existing.challenge
-            };
-            if (cause?.message)
-                options.message = cause.message;
-            return new ConnectionAuthorizationRequiredError(connection.name, {
-                ...options
-            });
-        }
-        const callbackUrl = this.callbackUrl();
-        const id = randomUUID();
-        const state = randomUrlToken();
-        const expiresAt = Date.now() + 10 * 60_000;
-        let challenge;
-        let resume;
-        let codeVerifier;
-        if (authorization.kind === "oauth" && authorization.oauth) {
-            codeVerifier = randomUrlToken(48);
-            const oauthChallengeOptions = {
-                state,
-                callbackUrl,
-                codeVerifier
-            };
-            if (authorization.displayName)
-                oauthChallengeOptions.displayName = authorization.displayName;
-            challenge = buildOAuthChallenge(authorization.oauth, oauthChallengeOptions);
-        }
-        else if (authorization.startAuthorization) {
-            const started = await authorization.startAuthorization({ principal, connection: connectionContext, callbackUrl, state });
-            challenge = started.challenge;
-            resume = started.resume;
-            if (!challenge.url && cause?.challenge?.url)
-                challenge.url = cause.challenge.url;
-            if (!challenge.instructions && cause?.challenge?.instructions)
-                challenge.instructions = cause.challenge.instructions;
-        }
-        else {
-            challenge = cause?.challenge ?? { instructions: `Authorize connection ${connection.name} and retry.` };
-            if (authorization.displayName)
-                challenge.displayName = authorization.displayName;
-        }
-        challenge.sessionId = id;
-        challenge.state = state;
-        challenge.expiresAt = expiresAt;
-        const session = {
-            id,
-            state,
-            connectionName: connection.name,
-            principal,
-            principalKey,
-            session: context.session,
-            callbackUrl,
-            challenge,
-            status: "pending",
-            expiresAt,
-            createdAt: timestamp(),
-            updatedAt: timestamp()
-        };
-        if (codeVerifier)
-            session.codeVerifier = codeVerifier;
-        if (resume !== undefined)
-            session.resume = resume;
-        const execution = this.executionContext.getStore();
-        const runId = execution?.runId ?? this.options.runId;
-        if (runId)
-            session.runId = runId;
-        if (execution?.toolCallId)
-            session.toolCallId = execution.toolCallId;
-        if (execution?.toolName)
-            session.toolName = execution.toolName;
-        await this.authorizationSessionStore.createSession(session);
-        const errorOptions = {
-            reason: cause?.reason ?? "authorization_required",
-            challenge
-        };
-        if (cause?.message)
-            errorOptions.message = cause.message;
-        return new ConnectionAuthorizationRequiredError(connection.name, errorOptions);
-    }
-    callbackUrl() {
-        const base = (this.options.callbackBaseUrl ?? this.options.config?.ASSEMBLY_LINE_PUBLIC_URL ?? "http://localhost").replace(/\/+$/u, "");
-        return `${base}/assembly-line/connections/callback`;
-    }
-    async exchangeOAuthAuthorizationCode(oauth, session, callback) {
-        const code = callback.params.code;
-        if (!code) {
-            throw new ConnectionAuthorizationFailedError(session.connectionName, { reason: "missing_code", retryable: true });
-        }
-        return this.requestOAuthToken(oauth, {
-            grant_type: "authorization_code",
-            code,
-            redirect_uri: oauth.redirectUri ?? session.callbackUrl,
-            code_verifier: session.codeVerifier
-        });
-    }
-    async refreshOAuthGrant(oauth, connectionName, principal, principalKey, refreshToken) {
-        const token = await this.requestOAuthToken(oauth, {
-            grant_type: "refresh_token",
-            refresh_token: refreshToken
-        });
-        if (!token.refreshToken)
-            token.refreshToken = refreshToken;
-        await this.saveGrantFromToken(connectionName, principal, principalKey, token);
-        return token;
-    }
-    async requestOAuthToken(oauth, fields) {
-        const body = new URLSearchParams();
-        const headers = {
-            accept: "application/json",
-            "content-type": "application/x-www-form-urlencoded"
-        };
-        if (oauth.tokenEndpointAuthMethod === "client_secret_basic") {
-            if (!oauth.clientSecret) {
-                throw new ConnectionAuthorizationFailedError("oauth", { reason: "missing_client_secret" });
-            }
-            headers.authorization = `Basic ${Buffer.from(`${oauth.clientId}:${oauth.clientSecret}`).toString("base64")}`;
-        }
-        else {
-            body.set("client_id", oauth.clientId);
-            if (oauth.clientSecret)
-                body.set("client_secret", oauth.clientSecret);
-        }
-        for (const [key, value] of Object.entries(oauth.tokenParams ?? {}))
-            body.set(key, value);
-        for (const [key, value] of Object.entries(fields)) {
-            if (value !== undefined)
-                body.set(key, value);
-        }
-        const response = await this.request(oauth.tokenUrl, {
-            method: "POST",
-            headers,
-            body
-        });
-        const payload = await readResponseBody(response);
-        if (!response.ok || !isRecord(payload)) {
-            throw new ConnectionAuthorizationFailedError("oauth", {
-                reason: "token_exchange_failed",
-                message: `OAuth token exchange failed with HTTP ${response.status}.`
-            });
-        }
-        const accessToken = stringValue(payload.access_token);
-        if (!accessToken) {
-            throw new ConnectionAuthorizationFailedError("oauth", { reason: "missing_access_token" });
-        }
-        const token = { token: accessToken };
-        const refreshToken = stringValue(payload.refresh_token);
-        const tokenType = oauth.tokenType?.trim() || stringValue(payload.token_type);
-        const scope = stringValue(payload.scope);
-        const expiresIn = typeof payload.expires_in === "number" ? payload.expires_in : Number(payload.expires_in);
-        if (refreshToken)
-            token.refreshToken = refreshToken;
-        if (tokenType)
-            token.tokenType = tokenType;
-        if (scope)
-            token.scopes = scope.split(/\s+/u).filter(Boolean);
-        if (Number.isFinite(expiresIn) && expiresIn > 0)
-            token.expiresAt = Date.now() + expiresIn * 1000;
-        // Non-standard response fields (provider identity ids and the like) ride
-        // along as the grant's credential bag; RFC 6749 §5.1 permits extras.
-        const credential = {};
-        for (const [key, value] of Object.entries(payload)) {
-            if (OAUTH_STANDARD_TOKEN_FIELDS.has(key))
-                continue;
-            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
-                credential[key] = value;
-        }
-        if (Object.keys(credential).length > 0)
-            token.credential = credential;
-        return token;
-    }
-    async saveGrantFromToken(connectionName, principal, principalKey, token) {
-        const now = timestamp();
-        const existing = await this.grantStore.getGrant(connectionName, principalKey);
-        const grant = {
-            connectionName,
-            principalKey,
-            principal,
-            token: token.token,
-            createdAt: existing?.createdAt ?? now,
-            updatedAt: now
-        };
-        if (token.refreshToken)
-            grant.refreshToken = token.refreshToken;
-        else if (existing?.refreshToken)
-            grant.refreshToken = existing.refreshToken;
-        if (token.tokenType)
-            grant.tokenType = token.tokenType;
-        if (token.scopes)
-            grant.scopes = token.scopes;
-        if (token.expiresAt)
-            grant.expiresAt = token.expiresAt;
-        // A response that omits extras must not erase identity captured earlier.
-        if (token.credential)
-            grant.credential = token.credential;
-        else if (existing?.credential)
-            grant.credential = existing.credential;
-        await this.grantStore.saveGrant(grant);
-    }
-}
-function sandboxCredentialWasRequested(run, connectionName) {
-    const requests = run?.input.sandboxCredentials;
-    return Boolean(requests
-        && typeof requests === "object"
-        && !Array.isArray(requests)
-        && Object.prototype.hasOwnProperty.call(requests, connectionName));
-}
-function isConnectionFactory(value) {
-    return Boolean(value && typeof value === "object" && typeof value.create === "function");
 }
 //# sourceMappingURL=connections.js.map