@fungi.computer/veil 0.3.0 → 0.5.0

package/dist/connections/cleanup.d.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import type * as Schema from "effect/Schema";
+import type { ConnectionsOptions } from "./contract.js";
+import { type AttemptRow, type ConnectionRow } from "./internal.js";
+/** The cleanup outbox, attempt retirement and reconnect marking over the owner's SQLite. */
+export declare function createCleanup(deps: {
+    ownerId: string;
+    custody: ConnectionsOptions["custody"];
+    clock: () => number;
+    sql: ConnectionsOptions["store"]["sql"];
+    transactionSync: <A>(body: () => A) => A;
+    rows: <S extends Schema.Decoder<unknown>>(schema: S, statement: string, ...bindings: (string | number | null)[]) => S["Type"][];
+    bump: () => void;
+}): {
+    cleanupPending: () => number;
+    sweep: () => Effect.Effect<void, import("./contract.js").ConnectionsError, never>;
+    enqueueLocator: (connectionId: string, locator: string, credential: ConnectionRow["credential"]) => void;
+    enqueueCleanup: (row: ConnectionRow) => void;
+    markReconnect: (id: string) => void;
+    retireAttempt: (attempt: AttemptRow, status: string) => void;
+};

package/dist/connections/cleanup.js

@@ -0,0 +1,66 @@
+import * as Effect from "effect/Effect";
+import { attemptRow, cleanupRow, connectionRow, count, sync, } from "./internal.js";
+const cleanupLimit = 5;
+/** The cleanup outbox, attempt retirement and reconnect marking over the owner's SQLite. */
+export function createCleanup(deps) {
+    const { sql, rows, bump, transactionSync } = deps;
+    /** Sealed credentials still waiting to be deleted; hosts wake their alarm while this is positive. */
+    const cleanupPending = () => rows(count, "SELECT COUNT(*) AS n FROM veil_connection_cleanup WHERE attempts < ?", cleanupLimit)[0]?.n ?? 0;
+    const sweep = () => Effect.gen(function* () {
+        yield* sync(expireAttempts);
+        const due = yield* sync(() => rows(cleanupRow, "SELECT * FROM veil_connection_cleanup WHERE attempts < ?", cleanupLimit));
+        for (const job of due) {
+            const outcome = yield* deps.custody
+                .remove({
+                ownerId: deps.ownerId,
+                connectionId: job.connectionId,
+                credential: job.credential,
+            }, job.locator)
+                .pipe(Effect.result);
+            yield* sync(() => {
+                if (outcome._tag === "Success")
+                    sql.exec("DELETE FROM veil_connection_cleanup WHERE id = ?", job.id);
+                else
+                    sql.exec("UPDATE veil_connection_cleanup SET attempts = attempts + 1 WHERE id = ?", job.id);
+            });
+        }
+    });
+    const enqueueLocator = (connectionId, locator, credential) => {
+        sql.exec("INSERT INTO veil_connection_cleanup (connectionId, locator, credential, attempts) VALUES (?, ?, ?, 0)", connectionId, locator, JSON.stringify(credential));
+    };
+    const enqueueCleanup = (row) => {
+        if (row.locator !== null)
+            enqueueLocator(row.id, row.locator, row.credential);
+    };
+    const markReconnect = (id) => {
+        sql.exec("UPDATE veil_connections SET state = 'reconnect_required', authorityVersion = authorityVersion + 1 WHERE id = ? AND state = 'active'", id);
+        bump();
+    };
+    /** An attempt ends: its sealed verifier goes to cleanup and a still-pending connection is withdrawn. */
+    const retireAttempt = (attempt, status) => {
+        sql.exec("UPDATE veil_connection_attempts SET status = ?, pkceVerifierSealed = NULL WHERE state = ?", status, attempt.state);
+        const row = rows(connectionRow, "SELECT * FROM veil_connections WHERE id = ?", attempt.connectionId)[0];
+        if (row === undefined)
+            return;
+        if (attempt.pkceVerifierSealed !== null)
+            enqueueLocator(row.id, attempt.pkceVerifierSealed, row.credential);
+        if (row.state === "pending") {
+            sql.exec("UPDATE veil_connections SET state = 'revoked', authorityVersion = authorityVersion + 1 WHERE id = ?", row.id);
+            bump();
+        }
+    };
+    const expireAttempts = () => {
+        transactionSync(() => {
+            for (const attempt of rows(attemptRow, "SELECT * FROM veil_connection_attempts WHERE status IN ('pending', 'consumed') AND expiresAt <= ?", deps.clock()))
+                retireAttempt(attempt, "expired");
+        });
+    };
+    return {
+        cleanupPending,
+        sweep,
+        enqueueLocator,
+        enqueueCleanup,
+        markReconnect,
+        retireAttempt,
+    };
+}

package/dist/connections/contract.d.ts

@@ -0,0 +1,287 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { PublicEgressPolicy } from "../public-egress-policy.js";
+export type ConnectionsRefusal = "invalid_input" | "denied" | "revoked" | "conflict" | "unsupported" | "too_large" | "reconnect_required" | "pending" | "invalid_response" | "unavailable";
+/** Fixed codes only: upstream bodies, URLs and credential bytes never enter errors. */
+export declare class ConnectionsError extends Error {
+    readonly code: ConnectionsRefusal;
+    readonly name = "ConnectionsError";
+    constructor(code: ConnectionsRefusal, options?: ErrorOptions);
+}
+export declare const identifier: Schema.String;
+declare const placementSchema: Schema.Union<readonly [Schema.Literal<"bearer">, Schema.Struct<{
+    readonly header: Schema.String;
+}>, Schema.Struct<{
+    readonly query: Schema.String;
+}>]>;
+export type Placement = typeof placementSchema.Type;
+/**
+ * How the final request is authorized. For `oauth` the owner may bring its own
+ * client (`clientId`, with the client secret as the draft's `secret`); without
+ * one the server's dynamic registration is used.
+ */
+export declare const credentialSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"none">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"static">;
+    readonly placement: Schema.Union<readonly [Schema.Literal<"bearer">, Schema.Struct<{
+        readonly header: Schema.String;
+    }>, Schema.Struct<{
+        readonly query: Schema.String;
+    }>]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"oauth">;
+    readonly scope: Schema.optional<Schema.String>;
+    readonly clientId: Schema.optional<Schema.String>;
+    /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+    readonly provider: Schema.optional<Schema.String>;
+}>]>;
+export type Credential = typeof credentialSchema.Type;
+export type SurfaceView = Readonly<{
+    kind: "mcp";
+    url: string;
+}> | Readonly<{
+    kind: "openapi";
+    baseUrl: string;
+    table: readonly unknown[];
+    /** Digest of the decoded operation table. */
+    digest: string;
+}>;
+export declare const toolsSchema: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+    readonly effect: Schema.Literal<"read">;
+}>, Schema.$Array<Schema.String>]>;
+export type Tools = typeof toolsSchema.Type;
+export declare const draftSchema: Schema.Struct<{
+    /** Idempotency key: a replay with the same request returns the same connection. */
+    readonly requestId: Schema.String;
+    readonly name: Schema.String;
+    /** Display text for owners; defaults to the name. */
+    readonly label: Schema.optional<Schema.String>;
+    readonly surface: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"mcp">;
+        readonly url: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"openapi">;
+        readonly baseUrl: Schema.String;
+        readonly table: Schema.$Array<Schema.Unknown>;
+    }>]>;
+    readonly credential: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"static">;
+        readonly placement: Schema.Union<readonly [Schema.Literal<"bearer">, Schema.Struct<{
+            readonly header: Schema.String;
+        }>, Schema.Struct<{
+            readonly query: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"oauth">;
+        readonly scope: Schema.optional<Schema.String>;
+        readonly clientId: Schema.optional<Schema.String>;
+        /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+        readonly provider: Schema.optional<Schema.String>;
+    }>]>;
+    readonly secret: Schema.optional<Schema.String>;
+}>;
+export type ConnectionDraft = typeof draftSchema.Type;
+export declare const grantInputSchema: Schema.Struct<{
+    readonly connectionId: Schema.String;
+    readonly agentId: Schema.String;
+    readonly tools: Schema.Union<readonly [Schema.Literal<"all">, Schema.Struct<{
+        readonly effect: Schema.Literal<"read">;
+    }>, Schema.$Array<Schema.String>]>;
+}>;
+export type GrantInput = typeof grantInputSchema.Type;
+/** The authorization server's redirect back to the owner. */
+export declare const completeInputSchema: Schema.Struct<{
+    readonly state: Schema.String;
+    readonly code: Schema.String;
+    readonly iss: Schema.optional<Schema.String>;
+}>;
+export type CompleteInput = typeof completeInputSchema.Type;
+/** Owner edits to a live connection, guarded by the version the owner last saw. */
+export declare const updateInputSchema: Schema.Struct<{
+    readonly requestId: Schema.String;
+    readonly connectionId: Schema.String;
+    readonly expectedVersion: Schema.Number;
+    readonly label: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+    /** Replacement OpenAPI operation table, decoded by Forage. */
+    readonly table: Schema.optional<Schema.$Array<Schema.Unknown>>;
+    readonly baseUrl: Schema.optional<Schema.String>;
+    /** Credential swap; `none` and `static` only. */
+    readonly credential: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"static">;
+        readonly placement: Schema.Union<readonly [Schema.Literal<"bearer">, Schema.Struct<{
+            readonly header: Schema.String;
+        }>, Schema.Struct<{
+            readonly query: Schema.String;
+        }>]>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"oauth">;
+        readonly scope: Schema.optional<Schema.String>;
+        readonly clientId: Schema.optional<Schema.String>;
+        /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+        readonly provider: Schema.optional<Schema.String>;
+    }>]>>;
+    readonly secret: Schema.optional<Schema.String>;
+}>;
+export type UpdateInput = typeof updateInputSchema.Type;
+/** One typed OpenAPI operation call. */
+export declare const callInputSchema: Schema.Struct<{
+    readonly operation: Schema.String;
+    readonly input: Schema.Unknown;
+}>;
+export type CallInput = typeof callInputSchema.Type;
+export declare const egressRefSchema: Schema.Struct<{
+    readonly connectionId: Schema.String;
+    readonly grantVersion: Schema.Number;
+}>;
+export type EgressRef = typeof egressRefSchema.Type;
+/** Where custody finds one connection; carries no secret. */
+export type CustodyAddress = Readonly<{
+    ownerId: string;
+    connectionId: string;
+    credential: Credential;
+}>;
+/**
+ * Owner-side credential custody. `sealed` stores ciphertext, `nango` a locator.
+ * Only `inject` ever opens a credential, and it sends the request itself.
+ */
+export type CustodyAdapter = Readonly<{
+    put: (address: CustodyAddress, secret: string) => Effect.Effect<string, ConnectionsError>;
+    inject: (address: CustodyAddress, locator: string, request: Request) => Effect.Effect<Response, ConnectionsError>;
+    remove: (address: CustodyAddress, locator: string) => Effect.Effect<"deleted" | "absent", ConnectionsError>;
+    /**
+     * Release a sealed OAuth bundle to the owner's connections core, which runs
+     * the authorization flow and refreshes tokens. Never reaches an Agent.
+     */
+    open?: (address: CustodyAddress, locator: string) => Effect.Effect<string, ConnectionsError>;
+    /**
+     * A custodian that runs the authorization itself (Nango's Connect) returns
+     * the page to send the owner to; it settles through a signed completion
+     * (`complete`) carrying the `state` given here, not through our callback.
+     */
+    connect?: (address: CustodyAddress, attempt: Readonly<{
+        state: string;
+        actor: string;
+        integrationId: string;
+    }>) => Effect.Effect<Readonly<{
+        connectUrl: string;
+        expiresAt: number;
+    }>, ConnectionsError>;
+}>;
+/**
+ * What a custodian proves after it ran an authorization: the attempt's state
+ * and where it keeps the credential. The host verifies the custodian's
+ * signature before it builds one.
+ */
+export type CustodyCompletion = Readonly<{
+    state: string;
+    locator: string;
+    /** The integration the custodian ran it through; it must be the one the attempt began with. */
+    integrationId: string;
+}>;
+export type SqlValue = string | number | null;
+/** The owner's SQLite in Cloudflare `ctx.storage` shape. */
+export type SqlStore = Readonly<{
+    sql: Readonly<{
+        exec: (statement: string, ...bindings: SqlValue[]) => Readonly<{
+            toArray: () => readonly unknown[];
+        }>;
+    }>;
+    transactionSync: <A>(operation: () => A) => A;
+}>;
+/**
+ * A REST provider the operator registered an app with. Such providers publish
+ * no metadata the SDK can discover, and many require a pre-registered client,
+ * so the host names the endpoints and holds the client. Only the operator's
+ * configuration reaches this type; neither an Agent nor an owner supplies one.
+ */
+export type StaticOAuthProvider = Readonly<{
+    issuer: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    /** Scopes requested when the owner names none. */
+    scope?: string;
+    client: {
+        client_id: string;
+        client_secret?: string | undefined;
+    };
+}>;
+export type ConnectionsOptions = Readonly<{
+    ownerId: string;
+    store: SqlStore;
+    custody: CustodyAdapter;
+    /** Host authority read: may this actor manage connections, or still stand as a grantor? */
+    authorize: (actorId: string, purpose: "manage" | "grantor") => boolean;
+    /**
+     * Asked right before every send, with the grantor who stands behind the
+     * grant. The host keeps its own live recheck here (membership, write
+     * rights); the core never learns what the host's policy is.
+     */
+    check?: (grantor: string, grant: Readonly<{
+        agentId: string;
+        connectionId: string;
+        tools: Tools;
+    }>, operation: Readonly<{
+        name: string;
+        effect: "read" | "write" | null;
+    }> | null) => Promise<boolean>;
+    egressPolicy?: PublicEgressPolicy;
+    /**
+     * Needed only for `oauth` connections: where the authorization server sends
+     * the owner back, and the checked public transport for discovery, token and
+     * refresh requests. Custody must also implement `open`.
+     */
+    oauth?: Readonly<{
+        callbackUrl: string;
+        fetch: (request: Request) => Promise<Response>;
+        /** REST providers the operator registered an app with, by id. */
+        providers?: Readonly<Record<string, StaticOAuthProvider>>;
+    }> | undefined;
+    clock: () => number;
+    ids: () => string;
+}>;
+/** Secret-free, versioned, and safe to hand to an Agent. */
+export type ConnectionProjection = Readonly<{
+    revision: number;
+    connections: readonly Readonly<{
+        connectionId: string;
+        name: string;
+        surface: SurfaceView;
+        tools: Tools;
+        /** Bumped by every `update`. */
+        version: number;
+        authorityVersion: number;
+        grantVersion: number;
+    }>[];
+}>;
+export type ConnectionView = Readonly<{
+    connectionId: string;
+    name: string;
+    label: string;
+    surface: Readonly<{
+        kind: "mcp" | "openapi";
+        origin: string;
+        url: string;
+        digest: string | null;
+    }>;
+    credentialKind: Credential["kind"];
+    /** How the secret is placed; the secret itself never appears. */
+    credential: Credential;
+    state: "pending" | "active" | "reconnect_required" | "revoked";
+    version: number;
+    authorityVersion: number;
+    grants: readonly Readonly<{
+        agentId: string;
+        tools: Tools;
+        version: number;
+        grantor: string;
+    }>[];
+}>;
+/** The Agent's narrowed capability: only the owner opens the credential. */
+export type NarrowFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export {};

package/dist/connections/contract.js

@@ -0,0 +1,95 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/** Fixed codes only: upstream bodies, URLs and credential bytes never enter errors. */
+export class ConnectionsError extends Error {
+    code;
+    name = "ConnectionsError";
+    constructor(code, options) {
+        super(code, options);
+        this.code = code;
+    }
+}
+export const identifier = Schema.String.pipe(Schema.check(Schema.isPattern(/^[A-Za-z0-9_.:-]{1,128}$/u)));
+const headerName = Schema.String.pipe(Schema.check(Schema.isPattern(/^[A-Za-z0-9-]{1,64}$/u)));
+const queryName = Schema.String.pipe(Schema.check(Schema.isPattern(/^[A-Za-z0-9_.-]{1,64}$/u)));
+const version = Schema.Number.pipe(Schema.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1)));
+const placementSchema = Schema.Union([
+    Schema.Literal("bearer"),
+    Schema.Struct({ header: headerName }),
+    Schema.Struct({ query: queryName }),
+]);
+/**
+ * How the final request is authorized. For `oauth` the owner may bring its own
+ * client (`clientId`, with the client secret as the draft's `secret`); without
+ * one the server's dynamic registration is used.
+ */
+export const credentialSchema = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("none") }),
+    Schema.Struct({ kind: Schema.Literal("static"), placement: placementSchema }),
+    Schema.Struct({
+        kind: Schema.Literal("oauth"),
+        scope: Schema.optional(Schema.String),
+        clientId: Schema.optional(Schema.String),
+        /** An operator-registered REST provider; absent for an MCP server's own sign-in. */
+        provider: Schema.optional(Schema.String),
+    }),
+]);
+/** What the Agent can call. The OpenAPI table is decoded by Forage before it is stored. */
+const surfaceDraftSchema = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("mcp"), url: Schema.String }),
+    Schema.Struct({
+        kind: Schema.Literal("openapi"),
+        baseUrl: Schema.String,
+        table: Schema.Array(Schema.Unknown),
+    }),
+]);
+export const toolsSchema = Schema.Union([
+    Schema.Literal("all"),
+    /** OpenAPI only: every operation whose stored effect is `read`. */
+    Schema.Struct({ effect: Schema.Literal("read") }),
+    Schema.Array(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(256)))).pipe(Schema.check(Schema.isMaxLength(256))),
+]);
+export const draftSchema = Schema.Struct({
+    /** Idempotency key: a replay with the same request returns the same connection. */
+    requestId: identifier,
+    name: Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128))),
+    /** Display text for owners; defaults to the name. */
+    label: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128)))),
+    surface: surfaceDraftSchema,
+    credential: credentialSchema,
+    secret: Schema.optional(Schema.String.pipe(Schema.check(Schema.isPattern(/^[\x21-\x7e]{1,16384}$/u)))),
+});
+export const grantInputSchema = Schema.Struct({
+    connectionId: identifier,
+    agentId: identifier,
+    tools: toolsSchema,
+});
+/** The authorization server's redirect back to the owner. */
+export const completeInputSchema = Schema.Struct({
+    state: Schema.String.pipe(Schema.check(Schema.isMaxLength(512))),
+    code: Schema.String.pipe(Schema.check(Schema.isMaxLength(4096))),
+    iss: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMaxLength(2048)))),
+});
+/** Owner edits to a live connection, guarded by the version the owner last saw. */
+export const updateInputSchema = Schema.Struct({
+    requestId: identifier,
+    connectionId: identifier,
+    expectedVersion: version,
+    label: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128)))),
+    name: Schema.optional(Schema.String.pipe(Schema.check(Schema.isMinLength(1), Schema.isMaxLength(128)))),
+    /** Replacement OpenAPI operation table, decoded by Forage. */
+    table: Schema.optional(Schema.Array(Schema.Unknown)),
+    baseUrl: Schema.optional(Schema.String),
+    /** Credential swap; `none` and `static` only. */
+    credential: Schema.optional(credentialSchema),
+    secret: Schema.optional(Schema.String.pipe(Schema.check(Schema.isPattern(/^[\x21-\x7e]{1,16384}$/u)))),
+});
+/** One typed OpenAPI operation call. */
+export const callInputSchema = Schema.Struct({
+    operation: Schema.String.pipe(Schema.check(Schema.isMaxLength(256))),
+    input: Schema.Unknown,
+});
+export const egressRefSchema = Schema.Struct({
+    connectionId: identifier,
+    grantVersion: version,
+});

package/dist/connections/core.d.ts

@@ -0,0 +1,98 @@
+import * as Effect from "effect/Effect";
+import { ConnectionsError, type CallInput, type ConnectionDraft, type Tools, type GrantInput, type ConnectionsOptions, type EgressRef, type NarrowFetch, type SurfaceView } from "./contract.js";
+/** One owner's connections: attempts, connections, grants, receipts and cleanup in its SQLite. */
+export declare function createConnections(options: ConnectionsOptions): {
+    begin: (actor: string, input: ConnectionDraft) => Effect.Effect<{
+        connectionId: string;
+        authorizeUrl: string | null;
+    }, ConnectionsError, never>;
+    complete: (actor: string, input: import("./contract.js").CompleteInput) => Effect.Effect<{
+        connectionId: string;
+    }, ConnectionsError, never>;
+    completeCustody: (input: import("./contract.js").CustodyCompletion) => Effect.Effect<{
+        connectionId: string;
+    }, ConnectionsError, never>;
+    grant: (actor: string, input: GrantInput) => Effect.Effect<{
+        grantVersion: number;
+    }, ConnectionsError, never>;
+    ungrant: (actor: string, input: {
+        connectionId: string;
+        agentId: string;
+    }) => Effect.Effect<void, ConnectionsError, never>;
+    revoke: (actor: string, input: {
+        connectionId: string;
+    }) => Effect.Effect<void, ConnectionsError, never>;
+    projection: (agentId: string) => Effect.Effect<{
+        revision: number;
+        connections: {
+            connectionId: string;
+            name: string;
+            surface: SurfaceView;
+            tools: readonly string[] | "all" | {
+                readonly effect: "read";
+            };
+            version: number;
+            authorityVersion: number;
+            grantVersion: number;
+        }[];
+    }, ConnectionsError, never>;
+    list: (actor: string) => Effect.Effect<Readonly<{
+        connectionId: string;
+        name: string;
+        label: string;
+        surface: Readonly<{
+            kind: "mcp" | "openapi";
+            origin: string;
+            url: string;
+            digest: string | null;
+        }>;
+        credentialKind: import("./contract.js").Credential["kind"];
+        credential: import("./contract.js").Credential;
+        state: "pending" | "active" | "reconnect_required" | "revoked";
+        version: number;
+        authorityVersion: number;
+        grants: readonly Readonly<{
+            agentId: string;
+            tools: Tools;
+            version: number;
+            grantor: string;
+        }>[];
+    }>[], ConnectionsError, never>;
+    egress: (agentId: string, input: EgressRef) => NarrowFetch;
+    call: (agentId: string, input: EgressRef, raw: CallInput) => Effect.Effect<import("zod").JSONType, ConnectionsError, never>;
+    ownerCall: (actor: string, at: Readonly<{
+        connectionId: string;
+        expectedVersion: number;
+    }>, raw: CallInput) => Effect.Effect<import("zod").JSONType, ConnectionsError, never>;
+    tools: (actor: string, connectionId: string) => Effect.Effect<readonly string[], ConnectionsError, never>;
+    operations: (actor: string, id: string) => Effect.Effect<{
+        operations: {
+            status: "supported";
+            name: string;
+            method: "GET" | "HEAD" | "OPTIONS" | "POST" | "PUT" | "PATCH" | "DELETE";
+            path: string;
+            effect: "write" | "read";
+            description: string & import("zod").$brand<"ThirdPartyText">;
+            textSource: "third_party";
+            tags: (string & import("zod").$brand<"ThirdPartyText">)[];
+            parameters: {
+                name: string;
+                in: "header" | "path" | "query";
+                required: boolean;
+                schema: boolean | Record<string, import("zod").JSONType>;
+                style?: string | undefined;
+                explode?: boolean | undefined;
+                allowReserved?: boolean | undefined;
+            }[];
+            input: boolean | Record<string, import("zod").JSONType>;
+            output: boolean | Record<string, import("zod").JSONType>;
+        }[];
+        digest: string;
+    }, ConnectionsError, never>;
+    update: (actor: string, raw: import("./contract.js").UpdateInput) => Effect.Effect<{
+        connectionId: string;
+        version: number;
+    }, ConnectionsError, never>;
+    sweep: () => Effect.Effect<void, ConnectionsError, never>;
+    cleanupPending: () => number;
+};