@jini-ai/integrations 0.1.0

package/dist/composio/service.js

@@ -0,0 +1,758 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { classifyConnectorToolSafety, connectorDefinitionToDetail, } from './catalog.js';
+import { COMPOSIO_MAX_SECRET_STORE_BYTES, readPrivateBoundedUtf8File, toStructurallyBoundedJsonValue, } from './bounded-data.js';
+import { ComposioConnectorProvider, isComposioCredentialMaterial, } from './composio.js';
+import { ConnectorServiceError } from './errors.js';
+import { assertConnectorInputMatchesSchema } from './json-schema.js';
+import { withExclusiveFileLock } from './file-lock.js';
+import { CONNECTOR_MAX_OUTPUT_BYTES, protectConnectorOutput, } from './output-protection.js';
+function publicComposioAuthStart(auth) {
+    return {
+        kind: auth.kind,
+        ...(auth.redirectUrl === undefined ? {} : { redirectUrl: auth.redirectUrl }),
+        ...(auth.providerConnectionId === undefined ? {} : { providerConnectionId: auth.providerConnectionId }),
+        ...(auth.expiresAt === undefined ? {} : { expiresAt: auth.expiresAt }),
+    };
+}
+function isConnectorAuthStaleError(error, request) {
+    if (!(error instanceof ConnectorServiceError) || error.code !== 'CONNECTOR_EXECUTION_FAILED')
+        return false;
+    const details = error.details;
+    return details?.connectorId === request.connectorId
+        && details.toolName === request.toolName
+        && details.authStale === true;
+}
+function connectorAuthExpiredMessage(definition) {
+    return `${definition.name} authorization expired. Reconnect ${definition.name}.`;
+}
+export { ConnectorServiceError } from './errors.js';
+export { CONNECTOR_MAX_OUTPUT_BYTES, protectConnectorOutput, } from './output-protection.js';
+function nowIso(now) {
+    return new Date(now()).toISOString();
+}
+function cloneCredentialMaterial(credentials) {
+    const cloned = toStructurallyBoundedJsonValue(credentials);
+    if (cloned === null || typeof cloned !== 'object' || Array.isArray(cloned)) {
+        throw new TypeError('connector credentials must be a bounded JSON object');
+    }
+    return cloned;
+}
+export class InMemoryConnectorCredentialStore {
+    records = new Map();
+    get(connectorId) {
+        const record = this.records.get(connectorId);
+        return record === undefined ? undefined : { ...record, credentials: cloneCredentialMaterial(record.credentials) };
+    }
+    set(record) {
+        this.records.set(record.connectorId, { ...record, credentials: cloneCredentialMaterial(record.credentials) });
+    }
+    delete(connectorId) {
+        this.records.delete(connectorId);
+    }
+    deleteByProvider(provider) {
+        for (const [connectorId, record] of this.records.entries()) {
+            if (record.credentials.provider === provider)
+                this.records.delete(connectorId);
+        }
+    }
+}
+export class FileConnectorCredentialStore {
+    filePath;
+    constructor({ filePath }) {
+        if (!filePath.trim())
+            throw new TypeError('Composio credential filePath must not be empty.');
+        this.filePath = path.resolve(filePath);
+    }
+    get(connectorId) {
+        return this.readRecords()[connectorId];
+    }
+    set(record) {
+        withExclusiveFileLock(this.filePath, () => {
+            const records = this.readRecords();
+            records[record.connectorId] = { ...record, credentials: cloneCredentialMaterial(record.credentials) };
+            this.writeRecords(records);
+        });
+    }
+    delete(connectorId) {
+        withExclusiveFileLock(this.filePath, () => {
+            const records = this.readRecords();
+            if (records[connectorId] === undefined)
+                return;
+            delete records[connectorId];
+            this.writeRecords(records);
+        });
+    }
+    deleteByProvider(provider) {
+        withExclusiveFileLock(this.filePath, () => {
+            const records = this.readRecords();
+            let changed = false;
+            for (const [connectorId, record] of Object.entries(records)) {
+                if (record.credentials.provider === provider) {
+                    delete records[connectorId];
+                    changed = true;
+                }
+            }
+            if (changed)
+                this.writeRecords(records);
+        });
+    }
+    readRecords() {
+        try {
+            const parsed = JSON.parse(readPrivateBoundedUtf8File(this.filePath, COMPOSIO_MAX_SECRET_STORE_BYTES));
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                return {};
+            const records = {};
+            for (const [connectorId, value] of Object.entries(parsed)) {
+                if (!value || typeof value !== 'object' || Array.isArray(value))
+                    continue;
+                const raw = value;
+                if (raw.schemaVersion !== 1 || raw.connectorId !== connectorId || typeof raw.accountLabel !== 'string' || typeof raw.updatedAt !== 'string')
+                    continue;
+                if (!raw.credentials || typeof raw.credentials !== 'object' || Array.isArray(raw.credentials))
+                    continue;
+                if (raw.credentials.provider === 'composio' && !isComposioCredentialMaterial(raw.credentials))
+                    continue;
+                records[connectorId] = {
+                    schemaVersion: 1,
+                    connectorId,
+                    accountLabel: raw.accountLabel,
+                    credentials: cloneCredentialMaterial(raw.credentials),
+                    updatedAt: raw.updatedAt,
+                };
+            }
+            return records;
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT')
+                return {};
+            throw error;
+        }
+    }
+    writeRecords(records) {
+        const dir = path.dirname(this.filePath);
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        fs.chmodSync(dir, 0o700);
+        const tempPath = `${this.filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        const serialized = `${JSON.stringify(records, null, 2)}\n`;
+        if (Buffer.byteLength(serialized, 'utf8') > COMPOSIO_MAX_SECRET_STORE_BYTES) {
+            throw new RangeError(`Composio credentials exceed the ${COMPOSIO_MAX_SECRET_STORE_BYTES}-byte limit.`);
+        }
+        try {
+            fs.writeFileSync(tempPath, serialized, { encoding: 'utf8', mode: 0o600 });
+            fs.renameSync(tempPath, this.filePath);
+            fs.chmodSync(this.filePath, 0o600);
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch (cleanupError) {
+                if (!isErrno(cleanupError, 'ENOENT'))
+                    throw cleanupError;
+            }
+            throw error;
+        }
+    }
+}
+function cloneStatus(status) {
+    return {
+        status: status.status,
+        ...(status.accountLabel === undefined ? {} : { accountLabel: status.accountLabel }),
+        ...(status.lastError === undefined ? {} : { lastError: status.lastError }),
+    };
+}
+function isAutoConnectedConnector(definition) {
+    return (definition.authentication === 'local' || definition.authentication === 'none')
+        && definition.tools.every((tool) => tool.requiredScopes.length === 0);
+}
+function approvalRank(approval) {
+    switch (approval) {
+        case 'auto':
+            return 0;
+        case 'confirm':
+            return 1;
+        case 'disabled':
+            return 2;
+    }
+}
+function stricterApproval(...approvals) {
+    return approvals.reduce((left, right) => (approvalRank(left) >= approvalRank(right) ? left : right));
+}
+function runtimeSafetyForTool(tool) {
+    const classified = classifyConnectorToolSafety(tool);
+    if (classified.sideEffect !== 'read' || classified.approval !== 'auto')
+        return classified;
+    return tool.safety;
+}
+function defaultConnectedAccountLabel(definition) {
+    return definition.name;
+}
+/** In-memory connection state backed optionally by durable credentials. */
+export class ConnectorStatusService {
+    statuses = new Map();
+    now;
+    credentialStore;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.credentialStore = options.credentialStore;
+        for (const [connectorId, status] of Object.entries(options.initialStatuses ?? {})) {
+            this.statuses.set(connectorId, { ...cloneStatus(status), updatedAt: nowIso(this.now) });
+        }
+    }
+    setCredentialStore(credentialStore) {
+        this.credentialStore = credentialStore;
+    }
+    deleteCredentialsByProvider(provider) {
+        for (const [connectorId, status] of this.statuses.entries()) {
+            if (status.status !== 'connected')
+                continue;
+            const credential = this.getCredential(connectorId);
+            if (credential?.credentials.provider === provider)
+                this.statuses.delete(connectorId);
+        }
+        this.credentialStore?.deleteByProvider(provider);
+    }
+    getStatus(definition) {
+        if (definition.disabled)
+            return { status: 'disabled' };
+        const stored = this.statuses.get(definition.id);
+        if (stored)
+            return cloneStatus(stored);
+        const credentialRecord = this.getCredential(definition.id);
+        if (credentialRecord !== undefined) {
+            return { status: 'connected', accountLabel: credentialRecord.accountLabel };
+        }
+        if (isAutoConnectedConnector(definition)) {
+            return { status: 'connected', accountLabel: defaultConnectedAccountLabel(definition) };
+        }
+        return { status: 'available' };
+    }
+    listStatuses() {
+        return Object.fromEntries(Array.from(this.statuses.entries()).map(([connectorId, status]) => [connectorId, cloneStatus(status)]));
+    }
+    connect(definition, accountLabel, credentials) {
+        if (definition.disabled)
+            return { status: 'disabled' };
+        if (credentials !== undefined) {
+            this.credentialStore?.set({
+                schemaVersion: 1,
+                connectorId: definition.id,
+                accountLabel: accountLabel ?? defaultConnectedAccountLabel(definition),
+                credentials,
+                updatedAt: nowIso(this.now),
+            });
+        }
+        const next = {
+            status: 'connected',
+            accountLabel: accountLabel ?? defaultConnectedAccountLabel(definition),
+            updatedAt: nowIso(this.now),
+        };
+        this.statuses.set(definition.id, next);
+        return cloneStatus(next);
+    }
+    getCredential(connectorId) {
+        return this.credentialStore?.get(connectorId);
+    }
+    disconnect(definition) {
+        if (definition.disabled)
+            return { status: 'disabled' };
+        this.credentialStore?.delete(definition.id);
+        if (isAutoConnectedConnector(definition)) {
+            this.statuses.delete(definition.id);
+            return this.getStatus(definition);
+        }
+        const next = { status: 'available', updatedAt: nowIso(this.now) };
+        this.statuses.set(definition.id, next);
+        return cloneStatus(next);
+    }
+    setError(definition, lastError, accountLabel) {
+        if (definition.disabled)
+            return { status: 'disabled' };
+        const next = {
+            status: 'error',
+            ...(accountLabel === undefined ? {} : { accountLabel }),
+            lastError,
+            updatedAt: nowIso(this.now),
+        };
+        this.statuses.set(definition.id, next);
+        return cloneStatus(next);
+    }
+    markAuthenticationExpired(definition, lastError, accountLabel) {
+        this.credentialStore?.delete(definition.id);
+        return this.setError(definition, lastError, accountLabel);
+    }
+    clear(connectorId) {
+        this.statuses.delete(connectorId);
+    }
+}
+export const CONNECTOR_RUN_RATE_LIMIT_CALLS = 10;
+export const CONNECTOR_RUN_RATE_LIMIT_WINDOW_MS = 60_000;
+export const CONNECTOR_RUN_LIMIT_TTL_MS = 15 * 60_000;
+export const CONNECTOR_RUN_TOTAL_CALL_LIMIT = 60;
+export const COMPOSIO_AUTH_CONFIG_PREPARE_LIMIT = 100;
+const CONNECTOR_RUN_LIMIT_MAX_BUCKETS = 10_000;
+const CONNECTOR_RUN_IDENTIFIER_MAX_LENGTH = 256;
+const CONNECTOR_EXECUTE_IDENTIFIER_MAX_LENGTH = 256;
+const CONNECTOR_EXECUTE_INPUT_MAX_BYTES = 1024 * 1024;
+function canonicalRunIdentifier(value, label) {
+    const canonical = value.normalize('NFKC').trim().toLowerCase();
+    if (canonical.length === 0
+        || canonical.length > CONNECTOR_RUN_IDENTIFIER_MAX_LENGTH
+        || !/^[a-z0-9][a-z0-9._:@/-]*$/.test(canonical)) {
+        throw new ConnectorServiceError('CONNECTOR_RATE_LIMITED', `${label} must be a non-empty canonical identifier`, 400, { field: label, maxLength: CONNECTOR_RUN_IDENTIFIER_MAX_LENGTH });
+    }
+    return canonical;
+}
+function connectorRunLimitKey(context) {
+    const scopeId = canonicalRunIdentifier(context.scopeId, 'scopeId');
+    const sessionId = canonicalRunIdentifier(context.sessionId ?? `${context.purpose ?? 'agent_preview'}:no-session-id`, 'sessionId');
+    return `${scopeId}\0${sessionId}`;
+}
+function normalizeExecuteIdentifier(value, field) {
+    if (typeof value !== 'string') {
+        throw new ConnectorServiceError('CONNECTOR_INPUT_SCHEMA_MISMATCH', `${field} must be a string`, 400, { field, maxLength: CONNECTOR_EXECUTE_IDENTIFIER_MAX_LENGTH });
+    }
+    const normalized = value.normalize('NFKC').trim();
+    if (normalized.length === 0
+        || normalized.length > CONNECTOR_EXECUTE_IDENTIFIER_MAX_LENGTH
+        || /[\u0000-\u001f\u007f]/.test(normalized)) {
+        throw new ConnectorServiceError('CONNECTOR_INPUT_SCHEMA_MISMATCH', `${field} must be a bounded identifier`, 400, { field, maxLength: CONNECTOR_EXECUTE_IDENTIFIER_MAX_LENGTH });
+    }
+    return normalized;
+}
+/**
+ * Detaches and bounds an execute request before any provider or account I/O.
+ *
+ * @returns A normalized request whose input is a finite, acyclic JSON object.
+ * @throws {ConnectorServiceError} With a stable 400 contract for malformed or
+ * oversized identifiers, roots, structures, strings, or serialized payloads.
+ *
+ * @complexity Time: O(n), where n is the bounded input graph and serialized
+ * byte length. Space: O(n) for the detached JSON value and serialization.
+ * @overallScore 100/100
+ */
+function normalizeConnectorExecuteRequest(request) {
+    const connectorId = normalizeExecuteIdentifier(request.connectorId, 'connectorId');
+    const toolName = normalizeExecuteIdentifier(request.toolName, 'toolName');
+    let boundedInput;
+    try {
+        boundedInput = toStructurallyBoundedJsonValue(request.input);
+    }
+    catch {
+        throw new ConnectorServiceError('CONNECTOR_INPUT_SCHEMA_MISMATCH', 'connector input exceeds structural safety limits', 400, { connectorId, toolName });
+    }
+    if (boundedInput === null || typeof boundedInput !== 'object' || Array.isArray(boundedInput)) {
+        throw new ConnectorServiceError('CONNECTOR_INPUT_SCHEMA_MISMATCH', 'connector input must be a JSON object', 400, { connectorId, toolName });
+    }
+    const serializedBytes = Buffer.byteLength(JSON.stringify(boundedInput), 'utf8');
+    if (serializedBytes > CONNECTOR_EXECUTE_INPUT_MAX_BYTES) {
+        throw new ConnectorServiceError('CONNECTOR_INPUT_SCHEMA_MISMATCH', 'connector input exceeds the serialized byte limit', 400, {
+            connectorId,
+            toolName,
+            maxSerializedBytes: CONNECTOR_EXECUTE_INPUT_MAX_BYTES,
+            serializedBytes,
+        });
+    }
+    return {
+        connectorId,
+        toolName,
+        input: boundedInput,
+        ...(request.expectedAccountLabel === undefined
+            ? {}
+            : { expectedAccountLabel: request.expectedAccountLabel }),
+    };
+}
+function aggregateCatalogHydrationError() {
+    return new ConnectorServiceError('CONNECTOR_EXECUTION_FAILED', 'aggregate Composio catalog hydration is unsupported; hydrate one connector at a time', 400);
+}
+/**
+ * Application service that coordinates the Composio provider, connection
+ * status, durable credentials, safety policy, and execution limits.
+ */
+export class ComposioConnectorService {
+    runLimits = new Map();
+    provider;
+    statusService;
+    now;
+    constructor(options) {
+        this.provider = options.provider;
+        this.statusService = options.statusService ?? new ConnectorStatusService(options.now === undefined ? {} : { now: options.now });
+        this.now = options.now ?? Date.now;
+    }
+    setCredentialStore(credentialStore) {
+        this.statusService.setCredentialStore(credentialStore);
+    }
+    deleteCredentialsByProvider(provider) {
+        this.statusService.deleteCredentialsByProvider(provider);
+    }
+    async listDefinitions(signal) {
+        return this.provider.listDefinitions(signal);
+    }
+    async listHydratedDefinitions(signal) {
+        void signal;
+        throw aggregateCatalogHydrationError();
+    }
+    listFastDefinitions() {
+        return this.provider.getFastDefinitions();
+    }
+    getFastDefinition(connectorId) {
+        return this.listFastDefinitions().find((definition) => definition.id === connectorId);
+    }
+    async getDefinition(connectorId, signal) {
+        return this.provider.getDefinition(connectorId, signal);
+    }
+    async getHydratedDefinition(connectorId, signal) {
+        return this.provider.getHydratedDefinition(connectorId, signal, {
+            requireCurrentTools: true,
+        });
+    }
+    async getPreviewDefinition(connectorId, options) {
+        return this.provider.getPreviewDefinition(connectorId, options);
+    }
+    getStatus(definition) {
+        const status = this.statusService.getStatus(definition);
+        if (definition.authentication === 'composio'
+            && status.status === 'connected'
+            && this.getCredential(definition.id) === undefined) {
+            return { status: 'available' };
+        }
+        return status;
+    }
+    getCredential(connectorId) {
+        const credential = this.statusService.getCredential(connectorId);
+        const definition = this.getFastDefinition(connectorId);
+        if (definition?.authentication === 'composio'
+            && !this.provider.credentialMatchesDefinition(definition, credential?.credentials)) {
+            return undefined;
+        }
+        return credential;
+    }
+    async listConnectors(signal) {
+        return this.listFastDefinitions().map((definition) => this.toDetail(definition));
+    }
+    listConnectorStatuses() {
+        return {
+            ...this.statusService.listStatuses(),
+            ...Object.fromEntries(this.listFastDefinitions().map((definition) => [definition.id, this.getStatus(definition)])),
+        };
+    }
+    async listConnectorDiscovery(options = {}) {
+        if (options.refresh)
+            this.provider.clearDiscoveryCache();
+        let definitions;
+        if (options.hydrateTools) {
+            throw aggregateCatalogHydrationError();
+        }
+        else if (options.refresh) {
+            definitions = await this.provider.refreshCatalog(options.signal);
+        }
+        else {
+            definitions = await this.listDefinitions(options.signal);
+        }
+        return {
+            connectors: definitions.map((definition) => this.toDetail(definition)),
+            meta: {
+                provider: 'composio',
+                ...(options.refresh ? { refreshRequested: true } : {}),
+            },
+        };
+    }
+    async getConnector(connectorId, signal) {
+        const definition = await this.getDefinition(connectorId, signal);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        return this.toDetail(definition);
+    }
+    async getHydratedConnector(connectorId, signal) {
+        const definition = await this.getHydratedDefinition(connectorId, signal);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        return this.toDetail(definition);
+    }
+    async getPreviewConnector(connectorId, options) {
+        const definition = await this.getPreviewDefinition(connectorId, options);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        return this.toDetail(definition);
+    }
+    async prepareAuthConfigs(connectorIds, signal) {
+        const results = {};
+        const uniqueConnectorIds = [...new Set(connectorIds.map((id) => id.trim()).filter(Boolean))];
+        if (uniqueConnectorIds.length > COMPOSIO_AUTH_CONFIG_PREPARE_LIMIT) {
+            throw new ConnectorServiceError('CONNECTOR_RATE_LIMITED', 'too many connector auth configs requested in one batch', 413, {
+                requested: uniqueConnectorIds.length,
+                maximum: COMPOSIO_AUTH_CONFIG_PREPARE_LIMIT,
+            });
+        }
+        await mapWithConcurrency(uniqueConnectorIds, 8, async (connectorId) => {
+            const definition = this.getFastDefinition(connectorId) ?? await this.getDefinition(connectorId, signal);
+            if (!definition) {
+                results[connectorId] = { status: 'error', message: 'connector not found' };
+                return;
+            }
+            if (definition.authentication !== 'composio') {
+                results[connectorId] = { status: 'error', message: 'connector is not backed by Composio' };
+                return;
+            }
+            results[connectorId] = await this.provider.prepareAuthConfig(definition, signal);
+        });
+        return { results };
+    }
+    async connect(connectorId, options = {}) {
+        const definition = this.getFastDefinition(connectorId) ?? await this.getDefinition(connectorId, options.signal);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        let auth;
+        let detailDefinition = definition;
+        if (definition.authentication === 'composio' && options.credentials !== undefined) {
+            throw new ConnectorServiceError('CONNECTOR_EXECUTION_FAILED', 'Composio credentials cannot be supplied directly; complete the validated OAuth flow', 400, { connectorId });
+        }
+        if (definition.authentication === 'composio') {
+            if (!options.callbackUrl) {
+                throw new ConnectorServiceError('CONNECTOR_EXECUTION_FAILED', 'callbackUrl is required for Composio connectors', 400, { connectorId });
+            }
+            auth = await this.provider.connect(definition, options.callbackUrl, options.signal);
+            if (auth.kind === 'redirect_required' || auth.kind === 'pending') {
+                return { connector: this.toDetail(detailDefinition), auth: publicComposioAuthStart(auth) };
+            }
+            if (auth.credentials === undefined
+                || !this.provider.credentialMatchesDefinition(definition, auth.credentials)) {
+                throw new ConnectorServiceError('CONNECTOR_EXECUTION_FAILED', 'Composio reported a connected account without validated credential evidence', 502, { connectorId });
+            }
+            if (auth.credentials !== undefined) {
+                options = { ...options, ...(auth.accountLabel === undefined ? {} : { accountLabel: auth.accountLabel }), credentials: auth.credentials };
+            }
+        }
+        const status = this.statusService.connect(detailDefinition, options.accountLabel, options.credentials);
+        if (status.status === 'disabled') {
+            throw new ConnectorServiceError('CONNECTOR_DISABLED', 'connector is disabled', 403);
+        }
+        return { connector: this.toDetail(detailDefinition), ...(auth === undefined ? {} : { auth: publicComposioAuthStart(auth) }) };
+    }
+    async disconnect(connectorId, signal) {
+        const definition = this.getFastDefinition(connectorId) ?? await this.getDefinition(connectorId, signal);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        if (definition.authentication === 'composio') {
+            await this.provider.disconnect(definition, this.getCredential(connectorId)?.credentials, signal);
+        }
+        this.statusService.disconnect(definition);
+        return this.toDetail(definition);
+    }
+    async cancelPendingAuthorization(connectorId) {
+        const definition = this.getFastDefinition(connectorId) ?? await this.getDefinition(connectorId);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        if (definition.authentication === 'composio') {
+            this.provider.cancelPendingConnections(connectorId);
+        }
+        return this.toDetail(definition);
+    }
+    async completeComposioConnection(input) {
+        const definition = await this.getDefinition(input.connectorId, input.signal);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        if (definition.authentication !== 'composio') {
+            throw new ConnectorServiceError('CONNECTOR_EXECUTION_FAILED', 'connector is not backed by Composio', 400, { connectorId: input.connectorId });
+        }
+        const completed = await this.provider.completeConnection({ definition, state: input.state, ...(input.providerConnectionId === undefined ? {} : { providerConnectionId: input.providerConnectionId }), ...(input.status === undefined ? {} : { status: input.status }), ...(input.signal === undefined ? {} : { signal: input.signal }) });
+        this.statusService.connect(definition, completed.accountLabel, completed.credentials);
+        return this.toDetail(definition);
+    }
+    async execute(request, context) {
+        const normalizedRequest = normalizeConnectorExecuteRequest(request);
+        // Context identifiers are also public request material. Validate their
+        // canonical shape before current-schema hydration performs provider I/O.
+        connectorRunLimitKey(context);
+        // Execution always resolves a fresh hydrated definition. Persisted catalog
+        // data is a display/startup cache and is never an authority for side effects.
+        const definition = await this.getHydratedDefinition(normalizedRequest.connectorId, context.signal);
+        if (!definition) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_FOUND', 'connector not found', 404);
+        }
+        const connector = this.toDetail(definition);
+        if (connector.status === 'disabled') {
+            throw new ConnectorServiceError('CONNECTOR_DISABLED', 'connector is disabled', 403);
+        }
+        if (connector.status !== 'connected') {
+            throw new ConnectorServiceError('CONNECTOR_NOT_CONNECTED', 'connector is not connected', 403, {
+                connectorId: normalizedRequest.connectorId,
+                status: connector.status,
+            });
+        }
+        if (normalizedRequest.expectedAccountLabel !== undefined
+            && connector.accountLabel !== normalizedRequest.expectedAccountLabel) {
+            throw new ConnectorServiceError('CONNECTOR_NOT_CONNECTED', 'connector account changed since refresh approval', 409, {
+                connectorId: normalizedRequest.connectorId,
+                expectedAccountLabel: normalizedRequest.expectedAccountLabel,
+                currentAccountLabel: connector.accountLabel ?? null,
+            });
+        }
+        const tool = definition.allowedToolNames.includes(normalizedRequest.toolName)
+            ? definition.tools.find((candidate) => candidate.name === normalizedRequest.toolName)
+            : undefined;
+        if (!tool) {
+            throw new ConnectorServiceError('CONNECTOR_TOOL_NOT_FOUND', 'connector tool is not allowed', 404, {
+                connectorId: normalizedRequest.connectorId,
+                toolName: normalizedRequest.toolName,
+            });
+        }
+        const runtimeSafety = runtimeSafetyForTool(tool);
+        const effectiveApproval = stricterApproval(
+        // An absent host policy is not evidence of auto-approval. This matches
+        // the provider's independent fail-closed execution boundary.
+        definition.minimumApproval ?? 'disabled', tool.safety.approval, runtimeSafety.approval);
+        if (effectiveApproval !== 'auto' || runtimeSafety.sideEffect !== 'read') {
+            throw new ConnectorServiceError('CONNECTOR_SAFETY_DENIED', 'connector tool is not auto-approved read-only by current safety policy', 403, {
+                connectorId: normalizedRequest.connectorId,
+                toolName: normalizedRequest.toolName,
+                approvalPolicy: effectiveApproval,
+                safety: { ...runtimeSafety },
+            });
+        }
+        try {
+            if (tool.inputSchemaUnsupportedReason !== undefined)
+                throw new Error(tool.inputSchemaUnsupportedReason);
+            assertConnectorInputMatchesSchema(normalizedRequest.input, tool.inputSchemaJson);
+        }
+        catch (error) {
+            throw new ConnectorServiceError('CONNECTOR_INPUT_SCHEMA_MISMATCH', error.message, 400, {
+                connectorId: normalizedRequest.connectorId,
+                toolName: normalizedRequest.toolName,
+            });
+        }
+        this.enforceRunLimits(context);
+        let providerOutput;
+        try {
+            providerOutput = await this.executeConnectorProviderTool(normalizedRequest, context, definition, tool);
+        }
+        catch (error) {
+            if (isConnectorAuthStaleError(error, normalizedRequest)) {
+                this.statusService.markAuthenticationExpired(definition, connectorAuthExpiredMessage(definition), connector.accountLabel);
+            }
+            throw error;
+        }
+        const protectedOutput = protectConnectorOutput(providerOutput);
+        const output = protectedOutput.output;
+        const outputSummary = summarizeConnectorOutput(output);
+        return {
+            ok: true,
+            connectorId: normalizedRequest.connectorId,
+            ...(connector.accountLabel === undefined ? {} : { accountLabel: connector.accountLabel }),
+            toolName: normalizedRequest.toolName,
+            safety: { ...runtimeSafety },
+            output,
+            ...(outputSummary === undefined ? {} : { outputSummary }),
+            metadata: {
+                connectorId: normalizedRequest.connectorId,
+                toolName: normalizedRequest.toolName,
+                purpose: context.purpose ?? 'agent_preview',
+                outputSerializedBytes: protectedOutput.serializedBytes,
+                ...(protectedOutput.redacted ? { redacted: true } : {}),
+                ...(context.sessionId === undefined ? {} : { sessionId: context.sessionId }),
+            },
+        };
+    }
+    async executeConnectorProviderTool(request, context, resolvedDefinition, resolvedTool) {
+        const definition = resolvedDefinition ?? await this.getHydratedDefinition(request.connectorId, context.signal);
+        const tool = resolvedTool ?? definition?.tools.find((candidate) => candidate.name === request.toolName);
+        if (definition?.authentication === 'composio' && tool) {
+            return this.provider.execute(definition, tool, request.input, this.getCredential(request.connectorId)?.credentials, context.signal);
+        }
+        throw new ConnectorServiceError('CONNECTOR_EXECUTION_FAILED', 'connector provider is not implemented', 501, {
+            connectorId: request.connectorId,
+            toolName: request.toolName,
+        });
+    }
+    enforceRunLimits(context) {
+        const now = this.now();
+        this.pruneRunLimits(now);
+        const key = connectorRunLimitKey(context);
+        const current = this.runLimits.get(key);
+        if (current === undefined && this.runLimits.size >= CONNECTOR_RUN_LIMIT_MAX_BUCKETS) {
+            throw new ConnectorServiceError('CONNECTOR_RATE_LIMITED', 'connector run-limit bucket capacity exceeded', 429, {
+                bucketLimit: CONNECTOR_RUN_LIMIT_MAX_BUCKETS,
+            });
+        }
+        const state = current === undefined || now - current.windowStartedAt >= CONNECTOR_RUN_RATE_LIMIT_WINDOW_MS
+            ? { windowStartedAt: now, lastSeenAt: now, windowCalls: 0, totalCalls: current?.totalCalls ?? 0 }
+            : current;
+        if (state.totalCalls >= CONNECTOR_RUN_TOTAL_CALL_LIMIT) {
+            throw new ConnectorServiceError('CONNECTOR_RATE_LIMITED', 'connector tool run call limit exceeded', 429, {
+                sessionId: context.sessionId ?? null,
+                totalCallLimit: CONNECTOR_RUN_TOTAL_CALL_LIMIT,
+            });
+        }
+        if (state.windowCalls >= CONNECTOR_RUN_RATE_LIMIT_CALLS) {
+            throw new ConnectorServiceError('CONNECTOR_RATE_LIMITED', 'connector tool rate limit exceeded', 429, {
+                sessionId: context.sessionId ?? null,
+                rateLimit: CONNECTOR_RUN_RATE_LIMIT_CALLS,
+                windowMs: CONNECTOR_RUN_RATE_LIMIT_WINDOW_MS,
+            });
+        }
+        state.windowCalls += 1;
+        state.totalCalls += 1;
+        state.lastSeenAt = now;
+        this.runLimits.set(key, state);
+    }
+    pruneRunLimits(now = this.now()) {
+        for (const [key, state] of this.runLimits.entries()) {
+            if (now - state.lastSeenAt >= CONNECTOR_RUN_LIMIT_TTL_MS)
+                this.runLimits.delete(key);
+        }
+    }
+    toDetail(definition) {
+        const detail = connectorDefinitionToDetail(definition);
+        const status = this.getStatus(definition);
+        return {
+            ...detail,
+            status: status.status,
+            ...(status.accountLabel === undefined ? {} : { accountLabel: status.accountLabel }),
+            ...(status.lastError === undefined ? {} : { lastError: status.lastError }),
+            auth: {
+                ...detail.auth,
+                configured: detail.auth.configured || (definition.authentication === 'composio' && this.provider.isConfigured(definition)),
+            },
+        };
+    }
+}
+function summarizeConnectorOutput(output) {
+    const maybeToolName = output.toolName;
+    if (typeof maybeToolName === 'string') {
+        const data = output.data !== null && typeof output.data === 'object' && !Array.isArray(output.data)
+            ? output.data
+            : output;
+        if (typeof data.count === 'number')
+            return `${maybeToolName}: ${data.count} result${data.count === 1 ? '' : 's'}`;
+        if (typeof data.path === 'string')
+            return `${maybeToolName}: ${data.path}`;
+        if (typeof data.isRepository === 'boolean')
+            return `${maybeToolName}: ${data.isRepository ? 'repository found' : 'not a repository'}`;
+        return maybeToolName;
+    }
+    return undefined;
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    let nextIndex = 0;
+    const workerCount = Math.min(Math.max(1, concurrency), items.length);
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (nextIndex < items.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            await mapper(items[index]);
+        }
+    }));
+}
+function isErrno(error, code) {
+    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === code);
+}
+//# sourceMappingURL=service.js.map