@zackbart/connecta 0.24.4 → 0.25.0

package/dist/connectors/guarded-fetch.d.ts

@@ -1,96 +0,0 @@
-import type { ConnectorContext } from "../types.js";
-/** The methods a hand-written provider surface actually uses. */
-type GuardedMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-export interface GuardedRequest {
-    method: GuardedMethod;
-    /**
-     * Provider-relative path beginning with one `/`, resolved against the base
-     * URL's own path. Never an absolute URL, and never carrying `?` or `#` —
-     * query parameters go in `query`, where they are encoded rather than parsed.
-     */
-    path: string;
-    /** Search parameters; `undefined` values are dropped, others stringified. */
-    query?: Record<string, string | number | boolean | undefined>;
-    /**
-     * Per-request headers. `undefined` values are dropped, and a header that
-     * collides with an authentication header is refused rather than allowed to
-     * shadow it.
-     */
-    headers?: Record<string, string | undefined>;
-    /** JSON request body. Serialized here, with the `Content-Type` to match. */
-    body?: unknown;
-    /**
-     * A pre-framed body — `FormData`, text, bytes. Mutually exclusive with
-     * `body`, and no `Content-Type` is supplied: multipart needs `fetch` to pick
-     * the boundary, and anything else knows its own type.
-     */
-    rawBody?: BodyInit;
-}
-/**
- * One downstream response, read under the connector's byte ceiling.
- *
- * The accessors are the whole read surface — there is no escape to the
- * underlying `Response`, because an unbounded `.text()` on it is exactly the
- * mistake this type exists to remove. `status`, `ok`, and `headers` are the
- * raw facts a provider mapper needs to make its own classification.
- */
-interface GuardedResponse {
-    readonly status: number;
-    readonly ok: boolean;
-    readonly headers: Headers;
-    /** The body as bytes. */
-    bytes(): Promise<Uint8Array>;
-    /** The body decoded as UTF-8. */
-    text(): Promise<string>;
-    /** The body parsed as JSON; `undefined` for an empty body, throws on junk. */
-    json(): Promise<unknown>;
-    /** Parse JSON while distinguishing malformed content from transport failure. */
-    jsonResult(): Promise<{
-        value: unknown;
-    } | {
-        parseError: unknown;
-    }>;
-}
-/** Parse delta-seconds or an HTTP-date into a non-negative wait window. */
-export declare function retryAfterMs(headers: Headers): number | undefined;
-/**
- * Turn one response into the provider's own result, or throw the provider's
- * own typed failure. This is where status codes acquire meaning, and it is
- * always the provider's code.
- */
-type GuardedResponseMapper<T> = (response: GuardedResponse, ctx: ConnectorContext) => T | Promise<T>;
-export interface GuardedFetchOptions {
-    /**
-     * Provider name as it appears in normalized failure prose — "Cloudflare",
-     * "Notion". Used for messages only; it is never parsed.
-     */
-    provider: string;
-    /**
-     * Absolute base URL. Its origin and path prefix are the confinement: every
-     * request resolves beneath it or is refused.
-     */
-    baseUrl: string;
-    /**
-     * Headers proving the caller's identity, resolved once per request. Throwing
-     * a typed `auth_required` from here is the documented way to report a
-     * missing credential — the helper has no opinion about what a credential is.
-     */
-    authenticate: (ctx: ConnectorContext) => Record<string, string> | Promise<Record<string, string>>;
-    /** Constant headers sent with every request — `Accept`, an API version. */
-    headers?: Record<string, string>;
-    /**
-     * Ceiling on the response body, in bytes. Required, because a default here
-     * would be the helper guessing on a provider's behalf: what counts as an
-     * absurd response is a fact about the API, not about HTTP.
-     */
-    maxResponseBytes: number;
-}
-/** Send one guarded request and map its response with provider knowledge. */
-export type GuardedTransport = <T>(request: GuardedRequest, ctx: ConnectorContext, map: GuardedResponseMapper<T>) => Promise<T>;
-/**
- * Build the transport a connector sends every request through. `maxResponseBytes`
- * is required rather than defaulted: what counts as an absurd response is a fact
- * about the API, not about HTTP.
- */
-export declare function guardedFetch(options: GuardedFetchOptions): GuardedTransport;
-export {};

package/dist/credential-rules.d.ts

@@ -1,85 +0,0 @@
-import type { Connector, ConnectorCredentialConfig } from "./types.js";
-/** Which hook a testable credential is checked with. */
-type CredentialTestMode = "single" | "multiple";
-/** Operator-safe explanation shared by every surface that detects shape drift. */
-export declare const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR = "Stored credential fields do not match this connector's current declaration. Replace the credential before using or testing this connector.";
-export type StoredCredentialShape = {
-    state: "missing";
-} | {
-    state: "valid";
-    mode: CredentialTestMode;
-    /**
-     * Stored keys the connector no longer declares, sorted. Harmless — the
-     * credential works — but worth telling an operator about, since nothing
-     * else in `/ui` can show a field the declaration has stopped naming.
-     */
-    undeclared: string[];
-} | {
-    state: "mismatch";
-    mode: CredentialTestMode;
-    message: typeof STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR;
-};
-/**
- * Compare a connector's current declaration with the keys in its stored
- * credential. Values are deliberately ignored: callers may pass decrypted
- * values or `/credentials`' masked field metadata and get the same answer.
- *
- * The test is CONTAINMENT, not equality: the stored key set is compatible when
- * it holds every field currently declared — the reserved `value` key for a
- * single-value declaration, every declared name for a named one. Anything the
- * declaration asks for and the vault does not have is `mismatch`, which is
- * precisely what a renamed field, a newly added field, or a swap between the
- * two shapes produces. The swap needs no special case: `value` is never one of
- * the declared names, so single→named and named→single each leave the declared
- * side unsatisfied. An empty stored map (reachable through a hand-written
- * plaintext) satisfies nothing and is a mismatch too.
- *
- * Extra keys are NOT drift. They are what *dropping* a field leaves behind, and
- * every accessor a connector actually uses — `ctx.credential.get("apiKey")`,
- * `getAll().apiKey` — keeps returning the right secret across that redeploy.
- * Calling it drift would order an operator to re-enter a working secret that
- * many providers will not reissue in readable form. The leftovers come back as
- * `undeclared` instead, for a surface to mention without blocking anything.
- */
-export declare function storedCredentialShape(config: ConnectorCredentialConfig, stored: Readonly<Record<string, unknown>> | null): StoredCredentialShape;
-/**
- * The one sentence describing leftover stored fields, so every surface words it
- * the same way. Names only — the values stay in the vault, and a field name from
- * a previous declaration is not a secret. Deliberately reassuring: nothing is
- * broken, and the only thing an operator gains by acting is that a connector
- * iterating `getAll()` stops seeing a field its code no longer knows about.
- */
-export declare function describeUndeclaredCredentialFields(fields: string[]): string;
-/** A declared credential shape whose only test hook cannot test it. */
-export interface CredentialTestMismatch {
-    /** The shape the connector declared. */
-    shape: CredentialTestMode;
-    /** The hook it implements, which that shape cannot use. */
-    hook: "testCredential" | "testCredentials";
-}
-export interface CredentialTestRule {
-    /** The hook to call, or null when this credential cannot be tested at all. */
-    mode: CredentialTestMode | null;
-    /** Set only when the sole implemented hook is the one the shape cannot use. */
-    mismatch?: CredentialTestMismatch;
-}
-/**
- * The one rule deciding whether a connector's credential can be tested — read
- * by /credentials' `testable` flag, by `POST /ui/credentials/<id>/test` when
- * it picks a hook, and by the construction-time mismatch warning, so those
- * three cannot drift apart.
- *
- * The declared credential *shape* selects the hook: named `credential.fields`
- * are tested as a set by `testCredentials`, a single-value `credential` by
- * `testCredential` on the vault's reserved `value` field. The other hook is
- * never substituted — it would be handed a shape the connector never declared —
- * so a connector implementing only the mismatched hook is not testable, and
- * says so at construction rather than under an operator's click.
- */
-export declare function credentialTestRule(connector: Pick<Connector, "credential" | "testCredential" | "testCredentials">): CredentialTestRule;
-/**
- * One clause naming a mismatch, shared by the startup warning and the test
- * route's 400 so an operator reads the same explanation in both places.
- */
-export declare function describeCredentialTestMismatch(mismatch: CredentialTestMismatch): string;
-export {};

package/dist/execute.d.ts

@@ -1,154 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/server";
-import type { ActivityRequestContext } from "./activity.js";
-import type { DeferredWork } from "./connector-scope.js";
-import { type ToolResult } from "./meta-tools.js";
-import { InvocationFailure } from "./invocation.js";
-import type { RegistryView } from "./registry.js";
-import type { Executor, ExecutorProvider, Logger } from "./types.js";
-/** Complete entries plus an exact omission count, all inside this byte cap. */
-export declare const CONNECTOR_INVENTORY_MAX_BYTES = 256;
-/**
- * Default budgets for `connecta.emit`. The byte budget is a transport bound,
- * not a context bound — emitted image/audio blocks reach the model as media,
- * not base64 text — so it sits far above the 24k return-value guard: room for
- * two or three real screenshots after base64's 4/3 inflation, well short of a
- * file-hosting ambition (design record M5).
- */
-export declare const EXECUTE_MAX_EMITTED_BYTES = 4000000;
-export declare const EXECUTE_MAX_EMITTED_BLOCKS = 32;
-type ExecuteDiagnosticOperation = "search" | "describe" | "call";
-interface ExecuteOperationDiagnostics {
-    operation: ExecuteDiagnosticOperation;
-    count: number;
-    failures: number;
-    durationMs: number;
-    resultBytes: number;
-    catalogMs: number;
-    connectorMs: number;
-}
-declare class ExecuteDiagnostics {
-    private readonly started;
-    private readonly operations;
-    admissionMs: number;
-    setupMs: number;
-    executorWallMs: number;
-    private emitted?;
-    /** Numbers only, per R8 — and only once something was emitted, so a
-     * non-emitting run's diagnostics stay byte-for-byte what they were. */
-    recordEmitted(count: number, bytes: number): void;
-    private stats;
-    recordCatalog(operation: "search" | "describe", durationMs: number, ok: boolean, result?: unknown): void;
-    recordCall(outcome: {
-        ok: boolean;
-        durationMs: number;
-        timing: {
-            catalogMs: number;
-            connectorMs: number;
-        };
-        value?: unknown;
-    }): void;
-    finish(): {
-        timing: {
-            totalMs: number;
-            admissionMs: number;
-            setupMs: number;
-            executorWallMs: number;
-            catalogMs: number;
-            connectorMs: number;
-        };
-        operations: ExecuteOperationDiagnostics[];
-        emitted?: {
-            count: number;
-            bytes: number;
-        };
-    };
-}
-/**
- * One MCP content block a program may emit. The complete set, by design:
- * `resource` and `resource_link` are refused in ethos.md — pointers get
- * followed, and connecta serves no resources for them to point at.
- */
-export type EmittedBlock = {
-    type: "text";
-    text: string;
-} | {
-    type: "image";
-    data: string;
-    mimeType: string;
-} | {
-    type: "audio";
-    data: string;
-    mimeType: string;
-};
-export declare class EmitCollector {
-    private readonly maxBytes;
-    private readonly maxBlocks;
-    private readonly diagnostics?;
-    readonly blocks: EmittedBlock[];
-    bytes: number;
-    constructor(maxBytes: number, maxBlocks: number, diagnostics?: ExecuteDiagnostics | undefined);
-    accept(raw: unknown): void;
-}
-/**
- * Expose one host provider and typed guest errors. Catalogs load only when
- * the program calls a tool or asks search/describe.
- */
-export declare function buildSandboxProviders(registry: RegistryView, baseUrl: string, _logger: Logger, activity?: ActivityRequestContext, limits?: {
-    signal?: AbortSignal | undefined;
-    maxHostCalls?: number | undefined;
-    hostCallTimeoutMs?: number | undefined;
-    discoveryConcurrency?: number | undefined;
-    /** Per-connector deadline for in-program catalog probes. Default 30_000. */
-    probeTimeoutMs?: number | undefined;
-    onInvocationFailure?: ((failure: InvocationFailure) => void) | undefined;
-    diagnostics?: ExecuteDiagnostics | undefined;
-    /**
-     * Where `connecta.emit` collects. The handler that will deliver the
-     * blocks owns it; without one, emit fails loudly rather than accept
-     * blocks nobody will ever return.
-     */
-    emitCollector?: EmitCollector | undefined;
-    /** Runtime-owned tail for stale catalog refreshes. */
-    defer?: DeferredWork | undefined;
-}): Promise<ExecutorProvider[]>;
-/** The execute_code handler. Exported for direct testing. */
-export declare function createExecuteTool(registry: RegistryView, baseUrl: string, executor: Executor, logger: Logger, activity?: ActivityRequestContext, config?: {
-    discoveryConcurrency?: number | undefined;
-    probeTimeoutMs?: number | undefined;
-    maxEmittedBytes?: number | undefined;
-    maxEmittedBlocks?: number | undefined;
-    maxHostCalls?: number | undefined;
-    hostCallTimeoutMs?: number | undefined;
-    defer?: DeferredWork | undefined;
-}): ({ code, diagnostics: diagnosticsRequested }: {
-    code: string;
-    diagnostics?: boolean;
-}, options?: {
-    signal?: AbortSignal;
-}) => Promise<ToolResult>;
-/** Register the execute_code meta-tool. Only called when an executor is configured. */
-export declare function registerExecuteTool(server: McpServer, registry: RegistryView, ctx: {
-    baseUrl: string;
-    executor: Executor;
-    logger: Logger;
-    activity?: ActivityRequestContext | undefined;
-    requestSignal?: AbortSignal | undefined;
-    discoveryConcurrency?: number | undefined;
-    /**
-     * The deployment's configured per-connector probe deadline. Programs probe
-     * the same downstream catalogs the top-level tools do, so an operator who
-     * tightened `discovery.probeTimeoutMs` gets it honored inside the sandbox
-     * too rather than silently falling back to the 30s default.
-     */
-    probeTimeoutMs?: number | undefined;
-    /** Aggregate serialized-byte budget for connecta.emit. Default 4_000_000. */
-    maxEmittedBytes?: number | undefined;
-    /** Block-count budget for connecta.emit. Default 32. */
-    maxEmittedBlocks?: number | undefined;
-    /** Host calls one program may make. Default 20. */
-    maxHostCalls?: number | undefined;
-    /** Deadline per host call in milliseconds. Default 15_000. */
-    hostCallTimeoutMs?: number | undefined;
-    defer?: DeferredWork | undefined;
-}): void;
-export {};

package/dist/executor-result.d.ts

@@ -1,10 +0,0 @@
-import type { ExecuteResult } from "./types.js";
-export declare const MAX_EXECUTE_LOG_CHARS = 4000;
-export declare function serializeResultText(value: unknown): string;
-export declare function guardExecuteResultValue(value: unknown): unknown;
-export declare function truncateExecuteText(text: string, max: number): string;
-/**
- * Apply the public execute_code result/log policy before a child result enters
- * IPC. The parent repeats the guard for third-party Executor implementations.
- */
-export declare function prepareExecuteResultForTransport(outcome: ExecuteResult): ExecuteResult;

package/dist/executors/quickjs-child.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/executors/quickjs-protocol.d.ts

@@ -1,67 +0,0 @@
-import type { ExecuteResult } from "../types.js";
-import type { QuickJsRuntimeOptions } from "./quickjs-runtime.js";
-export declare const MAX_QUICKJS_IPC_BYTES: number;
-export declare const MAX_QUICKJS_LOG_TRANSPORT_BYTES: number;
-/** Preserve #84's stopgap before a host value enters the child/WASM process. */
-export declare const MAX_QUICKJS_HOST_RPC_BYTES: number;
-export interface RunPayload {
-    id: number;
-    code: string;
-    providers: Array<{
-        name: string;
-        prelude?: string;
-    }>;
-    options: QuickJsRuntimeOptions;
-}
-export type ParentToChildMessage = {
-    type: "run";
-    payloadJson: string;
-} | {
-    type: "host-result";
-    jobId: number;
-    callId: number;
-    payloadJson: string;
-};
-export type ChildToParentMessage = {
-    type: "ready";
-} | {
-    type: "host-call";
-    jobId: number;
-    callId: number;
-    payloadJson: string;
-} | {
-    type: "log";
-    jobId: number;
-    payloadJson: string;
-} | {
-    type: "result";
-    jobId: number;
-    payloadJson: string;
-};
-export interface HostCallPayload {
-    namespace: string;
-    functionName: string;
-    args: unknown[];
-}
-export type HostResultPayload = {
-    ok: true;
-    value: unknown;
-} | {
-    ok: false;
-    error: string;
-};
-export interface ExecutionPayload {
-    outcome: ExecuteResult;
-    /**
-     * Set by the runtime on wall-clock expiry. The parent recycles the child on
-     * this flag, never on error text a guest can fabricate.
-     */
-    timedOut?: boolean;
-}
-export declare function hostCallLabel(payload: {
-    namespace: string;
-    functionName: string;
-    args: unknown[];
-}): string;
-export declare function serializedBytes(text: string): number;
-export declare function stringifyBounded(value: unknown, label: string, limit?: number): string;

package/dist/favicon.d.ts

@@ -1 +0,0 @@
-export declare const CONNECTA_FAVICON_ICO: Uint8Array<ArrayBufferLike>;

package/dist/identity.d.ts

@@ -1,4 +0,0 @@
-import type { IdentityReference } from "./types.js";
-export declare function validIdentityReference(value: IdentityReference | undefined): value is IdentityReference;
-/** Deterministic pseudonymous partition; raw emails and ids do not enter keys. */
-export declare function identityStorageKey(identity: IdentityReference): Promise<string>;

package/dist/invocation.d.ts

@@ -1,74 +0,0 @@
-import { type ActivityCallSource, type ActivityRequestContext, type AgentFriction } from "./activity.js";
-import { CatalogService, type ResolvedCatalogTool } from "./catalog-service.js";
-import { type CallErrorDetails } from "./errors.js";
-import { type RegistryView } from "./registry.js";
-export interface InvocationTiming {
-    catalogMs: number;
-    admissionMs: number;
-    connectorMs: number;
-    resultProcessingMs: number;
-    totalMs: number;
-}
-interface InvocationBase {
-    durationMs: number;
-    attempts: number;
-    timing: InvocationTiming;
-    resolved?: ResolvedCatalogTool;
-}
-export type InvocationOutcome<T> = (InvocationBase & {
-    ok: true;
-    value: T;
-    resolved: ResolvedCatalogTool;
-}) | (InvocationBase & {
-    ok: false;
-    error: CallErrorDetails;
-});
-export interface InvocationContext<T> {
-    source: ActivityCallSource;
-    allowDestructive?: boolean;
-    timeoutMs?: number;
-    requestSignal?: AbortSignal;
-    unwrapResult?: boolean;
-    /**
-     * Caller-owned result policy. MCP applies result paging here; code mode
-     * normally accepts the already-unwrapped value unchanged.
-     */
-    processResult?: (value: unknown, resolved: ResolvedCatalogTool) => T | Promise<T>;
-    /**
-     * Optional payload-free friction class derived from a *successful* result —
-     * today only an oversized one that had to be paged. It is deliberately not an
-     * `errorCode`: the call succeeded, and a consumer that keys its dashboards on
-     * "has an error code" must not count a truncation as a failure.
-     */
-    activityFriction?: (value: T) => AgentFriction | undefined;
-    /**
-     * Called after address/catalog/safety admission and before the first provider
-     * attempt. Code mode uses it for its host-call budget.
-     */
-    beforeDispatch?: () => void;
-}
-export declare class InvocationFailure extends Error {
-    readonly details: CallErrorDetails;
-    readonly code: string;
-    readonly retryable: boolean;
-    readonly retryAfterMs: number | undefined;
-    readonly connector: string | undefined;
-    readonly operation: string | undefined;
-    readonly recovery: CallErrorDetails["recovery"];
-    readonly nextAction: CallErrorDetails["nextAction"];
-    readonly retry: string | undefined;
-    constructor(details: CallErrorDetails);
-}
-/**
- * Shared downstream invocation engine. Address/catalog resolution is delegated
- * to the request-local CatalogService; every remaining call semantic lives
- * here so MCP and code mode cannot drift independently.
- */
-export declare class InvocationService {
-    private readonly registry;
-    private readonly catalog;
-    private readonly activity?;
-    constructor(registry: RegistryView, catalog: CatalogService, activity?: ActivityRequestContext | undefined);
-    invoke<T = unknown>(address: string, args: unknown, context: InvocationContext<T>): Promise<InvocationOutcome<T>>;
-}
-export {};

package/dist/mcp-result.d.ts

@@ -1,8 +0,0 @@
-import type { Connector } from "./types.js";
-/**
- * Unwrap an MCP CallToolResult into an ordinary JavaScript value:
- * `toolResult` wins when present, then `structuredContent`; all-text content is
- * JSON-parsed when possible. Downstream `isError` results become exceptions.
- * Non-MCP connectors already return plain values.
- */
-export declare function unwrapMcpResult(kind: Connector["kind"], result: unknown): unknown;

package/dist/meta-tools.d.ts

@@ -1,129 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/server";
-import type { ActivityRequestContext } from "./activity.js";
-import { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_SEARCH_LIMIT } from "./catalog-service.js";
-import type { DeferredWork } from "./connector-scope.js";
-import { type RegistryView } from "./registry.js";
-export { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_SEARCH_LIMIT, };
-interface TextContent {
-    type: "text";
-    text: string;
-}
-export interface ToolResult {
-    content: TextContent[];
-    isError?: boolean;
-    structuredContent?: Record<string, unknown>;
-    [x: string]: unknown;
-}
-export declare function jsonResult(obj: unknown, text?: string): ToolResult;
-export declare function errorResult(message: string): ToolResult;
-/**
- * Move a byte `offset` back to the nearest UTF-8 codepoint boundary in
- * `[0, offset]`, so decoding from it never starts mid-character (which emits
- * U+FFFD for the severed tail).
- *
- * Backwards, never forwards: re-serving a few bytes the caller already has is
- * recoverable, silently skipping the rest of a character is not. Offsets the
- * server itself produced (`nextOffset`) are already boundaries and come back
- * unchanged, so this only moves an offset a client computed on its own
- * (issue #38). An offset at or past `bytes.length` is left alone — there is no
- * character there to split.
- */
-export declare function alignStartToCharBoundary(bytes: Uint8Array, offset: number): number;
-/** End boundary for UTF-8-safe, forward-progressing result pages. See
- * documentation/meta-tools.md#result-representation. */
-export declare function alignEndToCharBoundary(bytes: Uint8Array, offset: number, end: number, total: number): number;
-export interface SearchArgs {
-    query?: string;
-    connector?: string;
-    safety?: "readOnly" | "approvalRequired" | "all";
-    limit?: number;
-    offset?: number;
-    fullDescriptions?: boolean;
-    includeSchemas?: "compact" | "json";
-}
-type ResultMode = "mcp" | "value";
-export interface CallArgs {
-    address: string;
-    args?: Record<string, unknown>;
-    resultMode?: ResultMode;
-    timeoutMs?: number;
-    /** Include connector/catalog/result-processing timing segments. */
-    diagnostics?: boolean;
-}
-export interface DestructiveCallArgs extends CallArgs {
-    /** Short model-authored context for the host's approval UI; never downstream input. */
-    reason?: string;
-}
-export interface GetResultArgs {
-    id: string;
-    /**
-     * Byte offset to page from; a whole number >= 0, aligned back to the nearest
-     * character boundary and reported as the response's `offset`. Defaults to 0.
-     */
-    offset?: number;
-    /** Page size in bytes; a whole number >= 1. Defaults to the deployment cap. */
-    maxBytes?: number;
-}
-export interface AuthorizeArgs {
-    connector: string;
-    force?: boolean;
-}
-export interface SkillArgs {
-    name?: string;
-}
-/**
- * Every meta-tool handler over a registry, one per registered tool. Exported for
- * direct testing; registerMetaTools() wires the six explicit tools onto an
- * McpServer. `opts.defaultToolTimeoutMs` supplies a deadline for calls that
- * don't carry one. (execute_code is registered separately by
- * registerExecuteTool, and builds its own services over the same registry.)
- *
- * What execute_code shares with these handlers is the services layer beneath
- * them — `CatalogService` and `InvocationService` — not the handlers, which no
- * in-program path calls.
- *
- * Deployment-wide result-size caps are read off the registry view rather than
- * passed in: `ConnectaConfig.calls.maxResultBytes` and its per-connector
- * override each have one runtime source of truth.
- */
-export declare function createMetaTools(registry: RegistryView, baseUrl: string, opts?: {
-    /** Deadline applied when a call passes no `timeoutMs`. Off when unset. */
-    defaultToolTimeoutMs?: number | undefined;
-    /** Per-connector deadline for the search/describe probe fan-out. Default 30_000. */
-    probeTimeoutMs?: number | undefined;
-    /** Maximum simultaneous connector discovery operations. Default 4. */
-    discoveryConcurrency?: number | undefined;
-    activity?: ActivityRequestContext | undefined;
-    canManageAuth?: ((id: string) => boolean) | undefined;
-    credentialHandoffUrl?: string | undefined;
-    /** Inbound request cancellation shared by every call this request makes. */
-    requestSignal?: AbortSignal | undefined;
-    /** Runtime-owned tail for stale catalog refreshes. */
-    defer?: DeferredWork | undefined;
-}): {
-    skills(args?: SkillArgs): Promise<ToolResult>;
-    searchTools(args: SearchArgs): Promise<ToolResult>;
-    callTool(args: CallArgs): Promise<ToolResult>;
-    callDestructiveTool(args: DestructiveCallArgs): Promise<ToolResult>;
-    getResult(args: GetResultArgs): Promise<ToolResult>;
-    authorizeConnector(args: AuthorizeArgs): Promise<ToolResult>;
-};
-/**
- * Register the six explicit meta-tools onto an McpServer instance.
- * `registerExecuteTool` adds the seventh, `execute_code`. Broad discovery and
- * multi-call work uses discovery and ordinary JavaScript promises inside a
- * program, which `execute_code` builds over the same
- * `CatalogService` and `InvocationService` these handlers use — one shared
- * services layer, two adapters above it.
- */
-export declare function registerMetaTools(server: McpServer, registry: RegistryView, ctx: {
-    baseUrl: string;
-    defaultToolTimeoutMs?: number | undefined;
-    probeTimeoutMs?: number | undefined;
-    discoveryConcurrency?: number | undefined;
-    activity?: ActivityRequestContext | undefined;
-    canManageAuth?: ((id: string) => boolean) | undefined;
-    credentialHandoffUrl?: string | undefined;
-    requestSignal?: AbortSignal | undefined;
-    defer?: DeferredWork | undefined;
-}): void;

package/dist/operator-ui/generated.d.ts

@@ -1,2 +0,0 @@
-export declare const OPERATOR_UI_CSS: string;
-export declare const OPERATOR_UI_SCRIPT: string;