@stacklink/sdk 0.2.0

package/dist/src/sdk/index.js

@@ -0,0 +1,2782 @@
+import { materializeStacklinkWorkbenchExecutionResponse, } from '../domain/stacklink-meta-tools.js';
+import { platformMcpTools } from '../domain/platform-mcp-tools.js';
+export { StacklinkMemoryLifecycle, StacklinkMemoryLifecycleError, createStacklinkMemoryLifecycle, serializeCompletedConversationTurn, } from './memory-lifecycle.js';
+export const platformToolSurfaceNames = platformMcpTools;
+export const stacklinkTypeScriptSdkVersion = '0.2.0';
+const workbenchReusableRunComparisonWaitMs = 120_000;
+const workbenchReusableRunComparisonPollMs = 1_000;
+export class StacklinkApiError extends Error {
+    statusCode;
+    code;
+    details;
+    constructor(message, statusCode, code, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = details;
+        this.name = 'StacklinkApiError';
+    }
+}
+function withoutCacheControl(input) {
+    const { cache: _cache, ...rest } = input;
+    return rest;
+}
+function discoveryServerBody(input) {
+    const body = withoutCacheControl(input);
+    if (input.cache === 'bypass')
+        body.cache = 'bypass';
+    return body;
+}
+function stableSdkStringify(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stableSdkStringify).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableSdkStringify(record[key])}`).join(',')}}`;
+}
+function uniqueSdkStrings(values) {
+    return Array.from(new Set(values));
+}
+function normalizeKnowledgePackSelection(value) {
+    if (Array.isArray(value)) {
+        return { enable: value.filter((entry) => typeof entry === 'string' && entry.length > 0), disable: [] };
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return {
+            enable: Array.isArray(record.enable) ? record.enable.filter((entry) => typeof entry === 'string' && entry.length > 0) : [],
+            disable: Array.isArray(record.disable) ? record.disable.filter((entry) => typeof entry === 'string' && entry.length > 0) : [],
+        };
+    }
+    return { enable: [], disable: [] };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function verifyWebhookSignature(input) {
+    const timestampSeconds = Number(input.timestamp);
+    if (!Number.isFinite(timestampSeconds))
+        return false;
+    const toleranceSeconds = input.toleranceSeconds ?? 300;
+    const nowSeconds = Math.floor((input.now ?? new Date()).getTime() / 1000);
+    if (Math.abs(nowSeconds - timestampSeconds) > toleranceSeconds)
+        return false;
+    const expected = await hmacSha256Base64(input.secret, `${input.id}.${input.timestamp}.${input.body}`);
+    for (const candidate of signatureCandidates(input.signature)) {
+        if (constantTimeStringEqual(candidate, expected))
+            return true;
+    }
+    return false;
+}
+function signatureCandidates(header) {
+    const candidates = [];
+    for (const entry of header.split(' ')) {
+        const parts = entry.split(',');
+        for (let index = 0; index < parts.length; index += 1) {
+            if (parts[index] === 'v1' && typeof parts[index + 1] === 'string') {
+                candidates.push(parts[index + 1] ?? '');
+            }
+        }
+    }
+    return candidates;
+}
+async function hmacSha256Base64(secret, value) {
+    const cryptoImpl = globalThis.crypto;
+    if (cryptoImpl?.subtle) {
+        const key = await cryptoImpl.subtle.importKey('raw', utf8(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const signature = await cryptoImpl.subtle.sign('HMAC', key, utf8(value));
+        return base64Encode(new Uint8Array(signature));
+    }
+    const { createHmac } = await import('node:crypto');
+    return createHmac('sha256', secret).update(value).digest('base64');
+}
+function constantTimeStringEqual(left, right) {
+    const leftBytes = utf8(left);
+    const rightBytes = utf8(right);
+    let diff = leftBytes.length ^ rightBytes.length;
+    const maxLength = Math.max(leftBytes.length, rightBytes.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        diff |= (leftBytes[index] ?? 0) ^ (rightBytes[index] ?? 0);
+    }
+    return diff === 0;
+}
+function utf8(value) {
+    return new TextEncoder().encode(value);
+}
+function base64Encode(bytes) {
+    if (typeof btoa === 'function') {
+        let binary = '';
+        for (const byte of bytes)
+            binary += String.fromCharCode(byte);
+        return btoa(binary);
+    }
+    return Buffer.from(bytes).toString('base64');
+}
+export class Stacklink {
+    apiKey;
+    registrationKey;
+    baseUrl;
+    fetchImpl;
+    cacheOptions;
+    responseCache = new Map();
+    webhooks;
+    triggers;
+    sessions;
+    logs;
+    apiKeys;
+    connectedAccounts;
+    authConfigs;
+    toolkits;
+    tools;
+    billing;
+    memory;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.registrationKey = options.registrationKey;
+        this.baseUrl = options.baseUrl.endsWith('/') ? options.baseUrl.slice(0, -1) : options.baseUrl;
+        this.fetchImpl = options.fetch ?? fetch;
+        this.cacheOptions = {
+            enabled: options.cache?.enabled ?? true,
+            toolsListTtlMs: options.cache?.toolsListTtlMs ?? 300_000,
+            toolkitsTtlMs: options.cache?.toolkitsTtlMs ?? 300_000,
+            schemasTtlMs: options.cache?.schemasTtlMs ?? 1_800_000,
+            searchTtlMs: options.cache?.searchTtlMs ?? 120_000,
+            maxEntries: options.cache?.maxEntries ?? 500,
+        };
+        this.webhooks = new StacklinkWebhooksClient(this);
+        this.triggers = new StacklinkTriggersClient(this);
+        this.sessions = new StacklinkSessionsClient(this);
+        this.logs = new StacklinkLogsClient(this);
+        this.apiKeys = new StacklinkApiKeysClient(this);
+        this.connectedAccounts = new StacklinkConnectedAccountsClient(this);
+        this.authConfigs = new StacklinkAuthConfigsClient(this);
+        this.toolkits = new StacklinkToolkitsClient(this);
+        this.tools = new StacklinkProviderToolsClient(this);
+        this.billing = new StacklinkBillingClient(this);
+        this.memory = new StacklinkMemoryClient(this);
+    }
+    sessionMcpConnection(descriptor) {
+        return {
+            url: descriptor.url,
+            headers: {
+                ...descriptor.headers,
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        };
+    }
+    async create(input) {
+        const response = await this.request('/v1/sessions', {
+            method: 'POST',
+            body: {
+                externalTenantId: input.tenantId,
+                externalUserId: input.userId,
+                tenantDisplayName: input.tenantDisplayName,
+                userDisplayName: input.userDisplayName,
+                userEmail: input.userEmail,
+                scopes: input.scopes ?? [],
+                toolRouter: input.toolRouter,
+                preset: input.preset,
+                preload: input.preload,
+                toolkits: input.toolkits,
+                tools: input.tools,
+                authConfigs: input.authConfigs,
+                connectedAccounts: input.connectedAccounts,
+                multiAccount: input.multiAccount,
+                workbench: input.workbench,
+                knowledgePacks: input.knowledgePacks,
+                memory: input.memory,
+                metaTools: input.metaTools,
+                metadata: input.metadata ?? {},
+            },
+        });
+        const projection = await this.getSessionMetaTools(response.session.id);
+        return new ToolRouterSession(this, response.session.id, response.session.tenantId, response.session.mcp, projection.contractVersion, projection.tools);
+    }
+    async use(sessionId) {
+        const response = await this.getSession(sessionId);
+        const projection = await this.getSessionMetaTools(sessionId);
+        return new ToolRouterSession(this, response.session.id, response.session.tenantId, response.session.mcp, projection.contractVersion, projection.tools);
+    }
+    clearCache(prefix) {
+        if (!prefix) {
+            this.responseCache.clear();
+            return;
+        }
+        for (const key of this.responseCache.keys()) {
+            if (key.startsWith(prefix))
+                this.responseCache.delete(key);
+        }
+    }
+    async listSessions(query = {}) {
+        return this.request('/v1/sessions', { query: { ...query } });
+    }
+    async getSession(sessionId) {
+        return this.request(`/v1/sessions/${sessionId}`);
+    }
+    async updateSession(sessionId, patch) {
+        const response = await this.request(`/v1/sessions/${sessionId}`, {
+            method: 'PATCH',
+            body: patch,
+        });
+        this.clearCache(`session:${sessionId}:`);
+        return response;
+    }
+    async closeSession(sessionId) {
+        return this.request(`/v1/sessions/${sessionId}/close`, {
+            method: 'POST',
+        });
+    }
+    async failSession(sessionId, input = {}) {
+        return this.request(`/v1/sessions/${sessionId}/fail`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async listSessionRouterFacts(sessionId, query = {}) {
+        return this.request(`/v1/sessions/${sessionId}/router-facts`, { query });
+    }
+    async listSessionConnectionEvents(sessionId) {
+        return this.request(`/v1/sessions/${sessionId}/connection-events`);
+    }
+    async getSessionTrace(sessionId, query = {}) {
+        return this.request(`/v1/sessions/${sessionId}/trace`, { query });
+    }
+    async getSessionConfigHistory(sessionId, query = {}) {
+        return this.request(`/v1/sessions/${sessionId}/config-history`, { query });
+    }
+    async getSessionWorkbench(sessionId) {
+        return this.request(`/v1/sessions/${sessionId}/workbench`);
+    }
+    async getSessionMetaTools(sessionId) {
+        return this.request(`/v1/sessions/${sessionId}/meta-tools`);
+    }
+    async createApiKey(input) {
+        return this.request('/v1/api-keys', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async deleteApiKey(apiKeyId) {
+        return this.request(`/v1/api-keys/${apiKeyId}`, {
+            method: 'DELETE',
+        });
+    }
+    async listProviders() {
+        return this.request('/v1/providers');
+    }
+    async listProjectProviders(query = {}) {
+        return this.request('/v1/project/providers', {
+            query: { tenantId: query.tenantId },
+        });
+    }
+    async listProviderTools(providerKey, input = {}) {
+        return this.request(`/v1/providers/${providerKey}/tools`, {
+            query: {
+                includePlanned: input.includePlanned === true ? 'true' : undefined,
+                responseMode: input.responseMode === 'compact' ? 'compact' : undefined,
+            },
+        });
+    }
+    async createProject(input) {
+        return this.request('/v1/projects', {
+            method: 'POST',
+            body: input,
+            registration: true,
+        });
+    }
+    async listProjects(input = {}) {
+        return this.request('/v1/projects', {
+            query: {
+                status: input.status,
+                limit: input.limit,
+                cursor: input.cursor,
+            },
+            registration: input.registration,
+        });
+    }
+    async getProject(projectId, input = {}) {
+        return this.request(`/v1/projects/${projectId}`, {
+            registration: input.registration,
+        });
+    }
+    async resetProjectAuthConfigs(projectId) {
+        return this.request(`/v1/projects/${projectId}/auth-configs/reset`, {
+            method: 'POST',
+            registration: true,
+        });
+    }
+    async listProjectProviderAccess(projectId) {
+        return this.request(`/v1/projects/${projectId}/providers`, {
+            registration: false,
+        });
+    }
+    async setProjectProviderAccess(projectId, providerKey, input = {}) {
+        return this.request(`/v1/projects/${projectId}/providers/${providerKey}`, {
+            method: 'PUT',
+            body: {
+                status: input.status ?? 'enabled',
+                enabledBy: input.enabledBy,
+                metadata: input.metadata ?? {},
+            },
+            registration: false,
+        });
+    }
+    async inspectConnectToken(publicToken) {
+        return this.request(`/v1/connect/${publicToken}`);
+    }
+    async completeConnectToken(publicToken, input) {
+        return this.request(`/v1/connect/${publicToken}/complete`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async startOAuthConnect(publicToken) {
+        return this.request(`/v1/connect/${publicToken}/oauth/start`);
+    }
+    async getConnectionRequest(requestId) {
+        return this.request(`/v1/connection-requests/${requestId}`);
+    }
+    async searchTools(input) {
+        return this.request('/v1/tools/search', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getToolSchemas(input) {
+        return this.request('/v1/tools/schemas', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getRuntimeToolContracts(input) {
+        return this.request('/v1/tools/runtime-contracts', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async executeTool(input, options = {}) {
+        return this.request('/v1/tools/execute', {
+            method: 'POST',
+            body: input,
+            signal: options.signal,
+        });
+    }
+    async executeToolsBatch(input, options = {}) {
+        return this.request('/v1/tools/execute-batch', {
+            method: 'POST',
+            body: input,
+            signal: options.signal,
+        });
+    }
+    async getSubscription() {
+        return this.request('/v1/subscription');
+    }
+    async listBillingPlans() {
+        return this.request('/v1/billing/plans');
+    }
+    async getUsage() {
+        return this.request('/v1/usage');
+    }
+    async listUsageEvents(query = {}) {
+        return this.request('/v1/usage/events', { query });
+    }
+    async createBillingCheckout(input) {
+        return this.request('/v1/billing/checkout', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async createBillingPortal(input = {}) {
+        return this.request('/v1/billing/portal', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async setWorkspaceSubscriptionPlanForProject(projectId, input) {
+        return this.request(`/v1/projects/${projectId}/subscription/plan`, {
+            method: 'POST',
+            body: input,
+            registration: true,
+        });
+    }
+    async listAuthConfigs(query = {}) {
+        return this.request('/v1/auth-configs', {
+            query: {
+                providerKey: query.providerKey,
+                includeDisabled: query.includeDisabled,
+            },
+        });
+    }
+    async createAuthConfig(input) {
+        return this.request('/v1/auth-configs', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async workbenchModels() {
+        return this.request('/v1/workbench/models');
+    }
+    async runWorkbench(input, options = {}) {
+        const response = await this.request('/v1/workbench/run', {
+            method: 'POST',
+            body: input,
+            signal: options.signal,
+        });
+        this.attachAbortSignalCancellation(input, response, options.signal);
+        if (input.operation === 'run_code' && input.background !== true) {
+            return this.waitForWorkbenchResponse(input, response, options);
+        }
+        return response;
+    }
+    async useWorkbenchSession(input) {
+        return this.request('/v1/workbench/sessions', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async deleteWorkbenchSession(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}`, {
+            method: 'DELETE',
+            query: { sessionId: input.sessionId },
+        });
+    }
+    async listWorkbenchFiles(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files`, { query: { sessionId: input.sessionId } });
+    }
+    async readWorkbenchFile(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files`, { query: { sessionId: input.sessionId, path: input.path } });
+    }
+    async uploadWorkbenchFile(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files`, {
+            method: 'PUT',
+            body: {
+                sessionId: input.sessionId,
+                path: input.path,
+                contentBase64: base64Encode(typeof input.content === 'string' ? utf8(input.content) : input.content),
+                contentType: input.contentType,
+                metadata: input.metadata,
+            },
+        });
+    }
+    async prepareWorkbenchFileUpload(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files/upload-url`, { method: 'POST', body: input });
+    }
+    async finalizeWorkbenchFileUpload(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files/finalize-upload`, { method: 'POST', body: input });
+    }
+    async uploadWorkbenchFileDirect(input) {
+        const content = typeof input.content === 'string' ? utf8(input.content) : input.content;
+        const contentType = input.contentType ?? (typeof input.content === 'string' ? 'text/plain; charset=utf-8' : 'application/octet-stream');
+        const prepared = await this.prepareWorkbenchFileUpload({
+            sessionId: input.sessionId,
+            workbenchSessionId: input.workbenchSessionId,
+            path: input.path,
+            contentType,
+            sizeBytes: content.byteLength,
+        });
+        const response = await this.fetchImpl(prepared.upload.uploadUrl, {
+            method: 'PUT',
+            headers: prepared.upload.requiredHeaders,
+            body: content,
+        });
+        if (!response.ok) {
+            throw new StacklinkApiError(`Workbench file upload failed with ${response.status}`, response.status, 'workbench_file_direct_upload_failed');
+        }
+        return this.finalizeWorkbenchFileUpload({
+            sessionId: input.sessionId,
+            workbenchSessionId: input.workbenchSessionId,
+            uploadId: prepared.upload.uploadId,
+            metadata: input.metadata,
+        });
+    }
+    async getWorkbenchFileDownload(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files/download-url`, { query: { sessionId: input.sessionId, path: input.path } });
+    }
+    async downloadWorkbenchFile(input) {
+        const signed = await this.getWorkbenchFileDownload(input);
+        const response = await this.fetchImpl(signed.downloadUrl);
+        if (!response.ok) {
+            throw new StacklinkApiError(`Workbench file download failed with ${response.status}`, response.status, 'workbench_file_download_failed');
+        }
+        return response;
+    }
+    async deleteWorkbenchFile(input) {
+        return this.request(`/v1/workbench/sessions/${input.workbenchSessionId}/files`, {
+            method: 'DELETE',
+            query: { sessionId: input.sessionId, path: input.path },
+        });
+    }
+    async createWorkbenchRunDefinition(input) {
+        return this.request('/v1/workbench/run-definitions', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async listWorkbenchRunDefinitions(input) {
+        return this.request('/v1/workbench/run-definitions', {
+            query: input,
+        });
+    }
+    async getWorkbenchRunDefinition(input) {
+        return this.request(`/v1/workbench/run-definitions/${input.runDefinitionId}`, { query: { sessionId: input.sessionId } });
+    }
+    async updateWorkbenchRunDefinition(input) {
+        return this.request(`/v1/workbench/run-definitions/${input.runDefinitionId}`, {
+            method: 'PATCH',
+            body: {
+                sessionId: input.sessionId,
+                name: input.name,
+                description: input.description,
+                versionReason: input.versionReason,
+            },
+        });
+    }
+    async replayWorkbenchRunDefinition(input) {
+        const accepted = await this.request(`/v1/workbench/run-definitions/${input.runDefinitionId}/replay`, {
+            method: 'POST',
+            body: {
+                sessionId: input.sessionId,
+                background: input.background,
+                timeoutMs: input.timeoutMs,
+                environmentMode: input.environmentMode,
+                idempotencyKey: input.idempotencyKey,
+            },
+        });
+        if (input.background === true)
+            return accepted;
+        const acceptedExecution = isSdkRecord(accepted.execution) ? accepted.execution : undefined;
+        if (!acceptedExecution)
+            return accepted;
+        const completedExecution = await this.waitForWorkbenchResponse({ sessionId: input.sessionId }, acceptedExecution);
+        const executionId = typeof completedExecution.executionId === 'string'
+            ? completedExecution.executionId
+            : accepted.comparison.replayExecutionId;
+        let comparison = accepted.comparison;
+        const comparisonDeadline = Date.now() + workbenchReusableRunComparisonWaitMs;
+        while (Date.now() <= comparisonDeadline) {
+            const definition = await this.getWorkbenchRunDefinition({
+                sessionId: input.sessionId,
+                runDefinitionId: accepted.runDefinition.id,
+            });
+            const replay = definition.runDefinition.replays?.find((entry) => entry.executionId === executionId);
+            if (replay)
+                comparison = replay.comparison;
+            if (comparison.status === 'matched' || comparison.status === 'mismatched')
+                break;
+            if (Date.now() >= comparisonDeadline)
+                break;
+            await sleep(workbenchReusableRunComparisonPollMs);
+        }
+        const executionLog = isSdkRecord(completedExecution.executionLog) ? completedExecution.executionLog : undefined;
+        const executionMetadata = executionLog && isSdkRecord(executionLog.metadata) ? executionLog.metadata : undefined;
+        const environment = executionMetadata && isSdkRecord(executionMetadata.replayEnvironment)
+            ? executionMetadata.replayEnvironment
+            : accepted.environment;
+        return {
+            ...accepted,
+            execution: completedExecution,
+            environment: environment,
+            comparison,
+        };
+    }
+    async publishWorkbenchRunDefinition(input) {
+        return this.request(`/v1/workbench/run-definitions/${input.runDefinitionId}/publish`, { method: 'POST', body: { sessionId: input.sessionId, expectedPublishedVersion: input.expectedPublishedVersion } });
+    }
+    async rollbackWorkbenchRunDefinition(input) {
+        return this.request(`/v1/workbench/run-definitions/${input.runDefinitionId}/rollback`, { method: 'POST', body: { sessionId: input.sessionId, expectedPublishedVersion: input.expectedPublishedVersion } });
+    }
+    async destroyWorkbenchSession(input, options = {}) {
+        return this.runWorkbench({
+            sessionId: input.sessionId,
+            workbenchSessionId: input.workbenchSessionId,
+            operation: 'destroy',
+        }, options);
+    }
+    async runWorkbenchBash(input, options = {}) {
+        const response = await this.request('/v1/workbench/bash', {
+            method: 'POST',
+            body: input,
+            signal: options.signal,
+        });
+        this.attachAbortSignalCancellation(input, response, options.signal);
+        if (input.background !== true) {
+            return this.waitForWorkbenchResponse(input, response, options);
+        }
+        return response;
+    }
+    async waitForWorkbenchResponse(input, accepted, options = {}) {
+        const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
+        const executionId = typeof accepted.executionId === 'string' ? accepted.executionId : undefined;
+        const executionKind = accepted.executionKind === 'workbench_code' || accepted.executionKind === 'workbench_bash'
+            ? accepted.executionKind
+            : undefined;
+        if (!sessionId || !executionId || !executionKind)
+            return accepted;
+        while (true) {
+            const waited = await this.waitForExecution({
+                sessionId,
+                executionKind,
+                executionId,
+                waitTimeoutMs: 10_000,
+                pollIntervalMs: 500,
+            }, options);
+            const execution = isSdkRecord(waited.execution) ? waited.execution : undefined;
+            if (execution && isTerminalSdkExecution(execution)) {
+                return materializeStacklinkWorkbenchExecutionResponse(accepted, execution);
+            }
+        }
+    }
+    async listExecutions(input, options = {}) {
+        return this.request('/v1/executions', {
+            query: {
+                sessionId: input.sessionId,
+                executionKind: input.executionKind,
+                workbenchSessionId: input.workbenchSessionId,
+                status: input.status,
+                cursor: input.cursor,
+                limit: input.limit,
+            },
+            signal: options.signal,
+        });
+    }
+    async getExecution(input, options = {}) {
+        return this.request(`/v1/executions/${input.executionKind}/${input.executionId}`, {
+            query: {
+                sessionId: input.sessionId,
+                includeEvents: input.includeEvents,
+                eventLimit: input.eventLimit,
+            },
+            signal: options.signal,
+        });
+    }
+    async readExecutionEvents(input, options = {}) {
+        return this.request(`/v1/executions/${input.executionKind}/${input.executionId}/events`, {
+            query: {
+                sessionId: input.sessionId,
+                afterSequence: input.afterSequence === undefined ? undefined : String(input.afterSequence),
+                limit: input.limit,
+            },
+            signal: options.signal,
+        });
+    }
+    async waitForExecution(input, options = {}) {
+        return this.request(`/v1/executions/${input.executionKind}/${input.executionId}/wait`, {
+            method: 'POST',
+            body: {
+                sessionId: input.sessionId,
+                waitTimeoutMs: input.waitTimeoutMs,
+                pollIntervalMs: input.pollIntervalMs,
+            },
+            signal: options.signal,
+        });
+    }
+    async cancelExecution(input, options = {}) {
+        return this.request(`/v1/executions/${input.executionKind}/${input.executionId}/cancel`, {
+            method: 'POST',
+            body: {
+                sessionId: input.sessionId,
+                reason: input.reason,
+            },
+            signal: options.signal,
+        });
+    }
+    async getAuthConfig(authConfigId) {
+        return this.request(`/v1/auth-configs/${authConfigId}`);
+    }
+    async updateAuthConfig(authConfigId, patch) {
+        return this.request(`/v1/auth-configs/${authConfigId}`, {
+            method: 'PATCH',
+            body: patch,
+        });
+    }
+    async enableAuthConfig(authConfigId) {
+        return this.request(`/v1/auth-configs/${authConfigId}/enable`, {
+            method: 'POST',
+        });
+    }
+    async disableAuthConfig(authConfigId) {
+        return this.request(`/v1/auth-configs/${authConfigId}/disable`, {
+            method: 'POST',
+        });
+    }
+    async deleteAuthConfig(authConfigId) {
+        return this.request(`/v1/auth-configs/${authConfigId}`, {
+            method: 'DELETE',
+        });
+    }
+    async listConnectedAccounts(tenantId) {
+        return this.request('/v1/connections', {
+            query: { tenantId },
+        });
+    }
+    async createConnectedAccount(input) {
+        return this.request('/v1/connections', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getConnectedAccount(accountId) {
+        return this.request(`/v1/connections/${accountId}`);
+    }
+    async listConnectedAccountTools(accountId, input = {}) {
+        return this.request(`/v1/connections/${accountId}/tools`, {
+            query: {
+                ...(input.includePlanned !== undefined ? { includePlanned: String(input.includePlanned) } : {}),
+                ...(input.toolKeys ? { toolKeys: input.toolKeys } : {}),
+            },
+        });
+    }
+    async listConnectedAccountResources(accountId, input = {}) {
+        return this.request(`/v1/connections/${accountId}/resources`, {
+            query: {
+                search: input.search,
+                resourceKey: input.resourceKey,
+                resourceKinds: input.resourceKinds,
+                cursor: input.cursor,
+                limit: input.limit,
+            },
+        });
+    }
+    async refreshConnectedAccountResources(accountId, input = {}) {
+        return this.request(`/v1/connections/${accountId}/resources/refresh`, {
+            method: 'POST',
+            query: {
+                search: input.search,
+                resourceKey: input.resourceKey,
+                resourceKinds: input.resourceKinds,
+                cursor: input.cursor,
+                limit: input.limit,
+            },
+        });
+    }
+    async resolveConnectedAccountResource(accountId, input) {
+        return this.request(`/v1/connections/${accountId}/resources/resolve`, { method: 'POST', body: input });
+    }
+    async updateConnectedAccount(accountId, patch) {
+        return this.request(`/v1/connections/${accountId}`, {
+            method: 'PATCH',
+            body: patch,
+        });
+    }
+    async enableConnectedAccount(accountId) {
+        return this.request(`/v1/connections/${accountId}/enable`, {
+            method: 'POST',
+        });
+    }
+    async disableConnectedAccount(accountId) {
+        return this.request(`/v1/connections/${accountId}/disable`, {
+            method: 'POST',
+        });
+    }
+    async refreshConnectedAccount(accountId) {
+        return this.request(`/v1/connections/${accountId}/refresh`, {
+            method: 'POST',
+        });
+    }
+    async validateConnectedAccount(accountId) {
+        return this.request(`/v1/connections/${accountId}/validate`, {
+            method: 'POST',
+        });
+    }
+    async deleteConnectedAccount(accountId) {
+        return this.request(`/v1/connections/${accountId}`, {
+            method: 'DELETE',
+        });
+    }
+    async listConnectedAccountSecrets(accountId) {
+        return this.request(`/v1/connections/${accountId}/secrets`);
+    }
+    async runConnectionHealthCheck(input = {}) {
+        return this.request('/v1/connections/health/run', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async listTriggerTypes(query = {}) {
+        return this.request('/v1/triggers/types', {
+            query: { providerKey: query.providerKey },
+        });
+    }
+    async listTriggerSubscriptions(query = {}) {
+        return this.request('/v1/triggers/subscriptions', {
+            query: { ...query },
+        });
+    }
+    async createTriggerSubscription(input) {
+        return this.request('/v1/triggers/subscriptions', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getTriggerSubscription(subscriptionId) {
+        return this.request(`/v1/triggers/subscriptions/${subscriptionId}`);
+    }
+    async updateTriggerSubscription(subscriptionId, patch) {
+        return this.request(`/v1/triggers/subscriptions/${subscriptionId}`, {
+            method: 'PATCH',
+            body: patch,
+        });
+    }
+    async deleteTriggerSubscription(subscriptionId) {
+        return this.request(`/v1/triggers/subscriptions/${subscriptionId}`, {
+            method: 'DELETE',
+        });
+    }
+    async listWebhookEventTypes() {
+        return this.request('/v1/webhook/event-types');
+    }
+    async getWebhook() {
+        return this.request('/v1/webhook');
+    }
+    async updateWebhook(input) {
+        return this.request('/v1/webhook', {
+            method: 'PUT',
+            body: input,
+        });
+    }
+    async rotateWebhookSecret() {
+        return this.request('/v1/webhook/rotate-secret', {
+            method: 'POST',
+        });
+    }
+    async sendWebhookTest(input) {
+        return this.request('/v1/webhook/test', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async verifyWebhookSignature(input) {
+        return verifyWebhookSignature(input);
+    }
+    async replayProviderEvent(eventId) {
+        return this.request(`/v1/events/${eventId}/replay`, {
+            method: 'POST',
+        });
+    }
+    async retryWebhookDelivery(deliveryId, input = {}) {
+        return this.request(`/v1/webhook-deliveries/${deliveryId}/retry`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async redriveDeadLetterWebhookDeliveries(input = {}) {
+        return this.request('/v1/webhook-deliveries/dead-letter/redrive', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async runTriggerPoller(input = {}) {
+        return this.request('/v1/triggers/poll/run', {
+            method: 'POST',
+            body: input,
+            registration: true,
+        });
+    }
+    async runTriggerDeliveries(input = {}) {
+        return this.request('/v1/triggers/deliveries/run', {
+            method: 'POST',
+            body: input,
+            registration: true,
+        });
+    }
+    async getProviderArtifact(artifactId) {
+        return this.request(`/v1/artifacts/${artifactId}`);
+    }
+    async getLogSummary(query = {}) {
+        return this.request('/v1/logs/summary', { query });
+    }
+    async listRequestLogs(query = {}) {
+        return this.request('/v1/logs/requests', { query });
+    }
+    async getRequestLog(logId) {
+        return this.request(`/v1/logs/requests/${logId}`);
+    }
+    async listToolLogs(query = {}) {
+        return this.request('/v1/logs/tools', { query });
+    }
+    async getToolLog(logId) {
+        return this.request(`/v1/logs/tools/${logId}`);
+    }
+    async listTriggerLogs(query = {}) {
+        return this.request('/v1/logs/triggers', { query });
+    }
+    async getTriggerLog(logId) {
+        return this.request(`/v1/logs/triggers/${logId}`);
+    }
+    async listWebhookDeliveries(query = {}) {
+        return this.request('/v1/logs/webhook-deliveries', { query });
+    }
+    async getWebhookDeliveryLog(deliveryId) {
+        return this.request(`/v1/logs/webhook-deliveries/${deliveryId}`);
+    }
+    async listWorkbenchSessions(query = {}) {
+        return this.request('/v1/workbench/sessions', {
+            query: {
+                tenantId: query.tenantId,
+                platformSessionId: query.platformSessionId,
+                status: query.status,
+                limit: query.limit,
+            },
+        });
+    }
+    async getWorkbenchSession(workbenchSessionId) {
+        return this.request(`/v1/workbench/sessions/${workbenchSessionId}`);
+    }
+    async getWorkbenchUsage(workbenchSessionId) {
+        return this.request(`/v1/workbench/sessions/${workbenchSessionId}/usage`);
+    }
+    async listWorkbenchArtifacts(query = {}) {
+        return this.request('/v1/workbench/artifacts', {
+            query: {
+                tenantId: query.tenantId,
+                workbenchSessionId: query.workbenchSessionId,
+                status: query.status,
+                limit: query.limit,
+            },
+        });
+    }
+    async getWorkbenchArtifactDownloadUrl(artifactId) {
+        return this.request(`/v1/workbench/artifacts/${artifactId}/download-url`);
+    }
+    async downloadWorkbenchArtifact(artifactId) {
+        return this.requestRaw(`/v1/workbench/artifacts/${artifactId}/download`);
+    }
+    async promoteWorkbenchArtifact(input) {
+        return this.request('/v1/workbench/artifacts', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async deleteWorkbenchArtifact(input) {
+        return this.request(`/v1/workbench/artifacts/${input.artifactId}`, {
+            method: 'DELETE',
+            query: {
+                sessionId: input.sessionId,
+                workbenchSessionId: input.workbenchSessionId,
+                path: input.path,
+            },
+        });
+    }
+    async listWorkbenchBudgets(query = {}) {
+        return this.request('/v1/workbench/budgets', {
+            query: {
+                tenantId: query.tenantId,
+                workbenchSessionId: query.workbenchSessionId,
+                status: query.status,
+                limit: query.limit,
+            },
+        });
+    }
+    async createWorkbenchBudget(input) {
+        return this.request('/v1/workbench/budgets', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async updateWorkbenchBudget(budgetPolicyId, patch) {
+        return this.request(`/v1/workbench/budgets/${budgetPolicyId}`, {
+            method: 'PATCH',
+            body: patch,
+        });
+    }
+    async deleteWorkbenchBudget(budgetPolicyId) {
+        return this.request(`/v1/workbench/budgets/${budgetPolicyId}`, {
+            method: 'DELETE',
+        });
+    }
+    async mcpRequest(input, options = {}) {
+        return this.mcpRequestAtPath('/v1/mcp', input, options);
+    }
+    async mcpSessionRequest(sessionId, input, options = {}) {
+        return this.mcpRequestAtPath(`/v1/sessions/${encodeURIComponent(sessionId)}/mcp`, input, options);
+    }
+    async mcpRequestAtPath(path, input, options = {}) {
+        return this.request(path, {
+            method: 'POST',
+            body: input,
+            signal: options.signal,
+        });
+    }
+    async mcpRequestStream(input, options = {}) {
+        return this.mcpRequestStreamAtPath('/v1/mcp', input, options);
+    }
+    async mcpSessionRequestStream(sessionId, input, options = {}) {
+        return this.mcpRequestStreamAtPath(`/v1/sessions/${encodeURIComponent(sessionId)}/mcp`, input, options);
+    }
+    async mcpRequestStreamAtPath(path, input, options = {}) {
+        let completed = false;
+        const cancel = () => {
+            if (completed)
+                return;
+            const requestId = input.id;
+            if (typeof requestId !== 'string' && typeof requestId !== 'number')
+                return;
+            void this.mcpRequestAtPath(path, {
+                jsonrpc: '2.0',
+                method: 'notifications/cancelled',
+                params: {
+                    requestId,
+                    reason: 'sdk_abort_signal',
+                },
+            }).catch(() => undefined);
+        };
+        if (options.signal?.aborted) {
+            cancel();
+        }
+        else {
+            options.signal?.addEventListener('abort', cancel, { once: true });
+        }
+        try {
+            const response = await this.requestRaw(path, {
+                method: 'POST',
+                body: input,
+                signal: options.signal,
+                headers: {
+                    accept: 'text/event-stream, application/json',
+                },
+            });
+            const contentType = response.headers.get('content-type') ?? '';
+            if (!contentType.includes('text/event-stream')) {
+                return await response.json().catch(() => null);
+            }
+            return await this.readMcpEventStream(response, options.onProgress);
+        }
+        finally {
+            completed = true;
+            options.signal?.removeEventListener('abort', cancel);
+        }
+    }
+    async listMcpTools() {
+        return this.mcpRequest({
+            jsonrpc: '2.0',
+            id: 'tools-list',
+            method: 'tools/list',
+        });
+    }
+    async callMcpTool(name, args) {
+        return this.mcpRequest({
+            jsonrpc: '2.0',
+            id: `${name}-call`,
+            method: 'tools/call',
+            params: {
+                name,
+                arguments: args,
+            },
+        });
+    }
+    async callSessionMcpTool(sessionId, name, args) {
+        return this.mcpSessionRequest(sessionId, {
+            jsonrpc: '2.0',
+            id: `${name}-call`,
+            method: 'tools/call',
+            params: {
+                name,
+                arguments: args,
+            },
+        });
+    }
+    async listKnowledgePacks() {
+        return this.request('/v1/knowledge/packs');
+    }
+    async getKnowledgeCapabilities(input = {}) {
+        const path = input.packKey
+            ? `/v1/knowledge/packs/${input.packKey}/capabilities`
+            : '/v1/knowledge/capabilities';
+        return this.request(path, input.sessionId
+            ? { query: { sessionId: input.sessionId } }
+            : {});
+    }
+    async listKnowledgeReleases(packKey) {
+        return this.request(`/v1/knowledge/packs/${packKey}/releases`);
+    }
+    async subscribeKnowledgePack(packKey, input = {}) {
+        return this.request(`/v1/knowledge/packs/${packKey}/subscribe`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async searchKnowledge(input) {
+        return this.request('/v1/knowledge/search', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async lookupKnowledgeCitation(input) {
+        return this.request('/v1/knowledge/citations/lookup', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getKnowledgeAmendmentTrail(input) {
+        return this.request('/v1/knowledge/amendments/trail', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async verifyKnowledgeEvidence(input) {
+        return this.request('/v1/knowledge/evidence/verify', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async verifyKnowledgeAnswer(input) {
+        return this.request('/v1/knowledge/answers/verify', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getGstComplianceRule(input) {
+        return this.request('/v1/gst-compliance/rules/query', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getGstDueDateRule(input) {
+        return this.request('/v1/gst-compliance/due-date/rule', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async calculateGstDueDate(input) {
+        return this.request('/v1/gst-compliance/due-date/calculate', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getGstLateFeeRule(input) {
+        return this.request('/v1/gst-compliance/late-fee/rule', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async calculateGstLateFee(input) {
+        return this.request('/v1/gst-compliance/late-fee/calculate', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getGstInterestRule(input) {
+        return this.request('/v1/gst-compliance/interest/rule', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async calculateGstInterest(input) {
+        return this.request('/v1/gst-compliance/interest/calculate', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async lookupGstHsnSacRate(input) {
+        return this.request('/v1/gst-compliance/rates/lookup', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async checkGstRcm(input) {
+        return this.request('/v1/gst-compliance/rcm/check', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getGstNoticeRule(input) {
+        return this.request('/v1/gst-compliance/notices/rule', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async getGstAppealStageRule(input) {
+        return this.request('/v1/gst-compliance/appeals/stage', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    attachAbortSignalCancellation(input, response, signal) {
+        if (!signal)
+            return;
+        const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
+        const executionId = typeof response.executionId === 'string'
+            ? response.executionId
+            : isSdkRecord(response.executionLog) && typeof response.executionLog.id === 'string'
+                ? response.executionLog.id
+                : undefined;
+        const executionKind = response.executionKind === 'workbench_bash' || response.executionKind === 'workbench_code'
+            ? response.executionKind
+            : undefined;
+        if (!sessionId || !executionId || !executionKind)
+            return;
+        const cancel = () => {
+            void this.cancelExecution({
+                sessionId,
+                executionKind,
+                executionId,
+                reason: 'sdk_abort_signal',
+            }).catch(() => undefined);
+        };
+        if (signal.aborted) {
+            cancel();
+            return;
+        }
+        signal.addEventListener('abort', cancel, { once: true });
+    }
+    async request(path, init = {}) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        for (const [key, value] of Object.entries(init.query ?? {})) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    if (entry !== undefined && entry !== null)
+                        url.searchParams.append(key, String(entry));
+                }
+            }
+            else if (value !== undefined && value !== null) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const headers = this.requestHeaders(init.registration === true, init.headers);
+        const response = await this.fetchImpl(url, {
+            method: init.method ?? 'GET',
+            headers,
+            ...(init.signal ? { signal: init.signal } : {}),
+            ...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+        });
+        const body = await response.json().catch(() => null);
+        if (!response.ok) {
+            const message = body && typeof body === 'object' && 'message' in body
+                ? String(body.message)
+                : `Stacklink request failed with ${response.status}`;
+            const code = body && typeof body === 'object' && 'code' in body && typeof body.code === 'string'
+                ? body.code
+                : undefined;
+            const details = body && typeof body === 'object' && 'details' in body
+                ? body.details
+                : undefined;
+            throw new StacklinkApiError(message, response.status, code, details);
+        }
+        return body;
+    }
+    async requestRaw(path, init = {}) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        for (const [key, value] of Object.entries(init.query ?? {})) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    if (entry !== undefined && entry !== null)
+                        url.searchParams.append(key, String(entry));
+                }
+            }
+            else if (value !== undefined && value !== null) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const response = await this.fetchImpl(url, {
+            method: init.method ?? 'GET',
+            headers: this.requestHeaders(init.registration === true, init.headers),
+            ...(init.signal ? { signal: init.signal } : {}),
+            ...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new StacklinkApiError(body || `Stacklink request failed with ${response.status}`, response.status);
+        }
+        return response;
+    }
+    async cachedDiscoveryRequest(cacheKey, ttlMs, control, producer) {
+        if (!this.cacheOptions.enabled || control?.cache === 'bypass')
+            return producer();
+        const now = Date.now();
+        const existing = this.responseCache.get(cacheKey);
+        if (existing && existing.expiresAt > now)
+            return existing.value;
+        const value = await producer();
+        this.responseCache.set(cacheKey, {
+            value,
+            expiresAt: now + ttlMs,
+        });
+        this.trimResponseCache();
+        return value;
+    }
+    discoveryCacheTtl(kind) {
+        if (kind === 'toolsList')
+            return this.cacheOptions.toolsListTtlMs;
+        if (kind === 'toolkits')
+            return this.cacheOptions.toolkitsTtlMs;
+        if (kind === 'schemas')
+            return this.cacheOptions.schemasTtlMs;
+        return this.cacheOptions.searchTtlMs;
+    }
+    trimResponseCache() {
+        const maxEntries = this.cacheOptions.maxEntries;
+        while (this.responseCache.size > maxEntries) {
+            const firstKey = this.responseCache.keys().next().value;
+            if (!firstKey)
+                break;
+            this.responseCache.delete(firstKey);
+        }
+    }
+    async readMcpEventStream(response, onProgress) {
+        if (!response.body)
+            throw new Error('Stacklink MCP stream response has no body.');
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let dataLines = [];
+        let finalResponse;
+        const handleLine = (line) => {
+            if (line.endsWith('\r'))
+                line = line.slice(0, -1);
+            if (line === '') {
+                if (dataLines.length > 0) {
+                    const data = dataLines.join('\n');
+                    dataLines = [];
+                    if (data.length > 0) {
+                        const message = JSON.parse(data);
+                        if (isSdkRecord(message) && message.method === 'notifications/progress' && isSdkRecord(message.params)) {
+                            onProgress?.(message.params);
+                        }
+                        else if (isSdkRecord(message) && ('result' in message || 'error' in message)) {
+                            finalResponse = message;
+                        }
+                    }
+                }
+                return;
+            }
+            if (line.startsWith('data:')) {
+                let value = line.slice(5);
+                if (value.startsWith(' '))
+                    value = value.slice(1);
+                dataLines.push(value);
+            }
+        };
+        while (true) {
+            const read = await reader.read();
+            if (read.done)
+                break;
+            buffer += decoder.decode(read.value, { stream: true });
+            let index = buffer.indexOf('\n');
+            while (index >= 0) {
+                handleLine(buffer.slice(0, index));
+                buffer = buffer.slice(index + 1);
+                index = buffer.indexOf('\n');
+            }
+        }
+        buffer += decoder.decode();
+        if (buffer.length > 0)
+            handleLine(buffer);
+        handleLine('');
+        if (finalResponse === undefined)
+            throw new Error('Stacklink MCP stream ended without a final JSON-RPC response.');
+        return finalResponse;
+    }
+    requestHeaders(registration, extraHeaders = {}) {
+        if (registration) {
+            if (!this.registrationKey) {
+                throw new Error('Stacklink registrationKey is required for registration/admin SDK methods.');
+            }
+            return {
+                'x-stacklink-registration-key': this.registrationKey,
+                'content-type': 'application/json',
+                ...extraHeaders,
+                'x-stacklink-client-channel': 'ts_sdk',
+                'x-stacklink-client-name': 'stacklink-ts',
+                'x-stacklink-client-version': stacklinkTypeScriptSdkVersion,
+            };
+        }
+        return {
+            authorization: `Bearer ${this.apiKey}`,
+            'content-type': 'application/json',
+            ...extraHeaders,
+            'x-stacklink-client-channel': 'ts_sdk',
+            'x-stacklink-client-name': 'stacklink-ts',
+            'x-stacklink-client-version': stacklinkTypeScriptSdkVersion,
+        };
+    }
+}
+export class StacklinkWebhooksClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    listEventTypes() {
+        return this.client.listWebhookEventTypes();
+    }
+    get() {
+        return this.client.getWebhook();
+    }
+    update(input) {
+        return this.client.updateWebhook(input);
+    }
+    rotateSecret() {
+        return this.client.rotateWebhookSecret();
+    }
+    sendTest(input) {
+        return this.client.sendWebhookTest(input);
+    }
+    retryDelivery(deliveryId, input = {}) {
+        return this.client.retryWebhookDelivery(deliveryId, input);
+    }
+    redriveDeadLetters(input = {}) {
+        return this.client.redriveDeadLetterWebhookDeliveries(input);
+    }
+    replayEvent(eventId) {
+        return this.client.replayProviderEvent(eventId);
+    }
+    verifySignature(input) {
+        return this.client.verifyWebhookSignature(input);
+    }
+}
+export class StacklinkTriggersClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    listTypes(query = {}) {
+        return this.client.listTriggerTypes(query);
+    }
+    listSubscriptions(query = {}) {
+        return this.client.listTriggerSubscriptions(query);
+    }
+    createSubscription(input) {
+        return this.client.createTriggerSubscription(input);
+    }
+    getSubscription(subscriptionId) {
+        return this.client.getTriggerSubscription(subscriptionId);
+    }
+    updateSubscription(subscriptionId, patch) {
+        return this.client.updateTriggerSubscription(subscriptionId, patch);
+    }
+    deleteSubscription(subscriptionId) {
+        return this.client.deleteTriggerSubscription(subscriptionId);
+    }
+    runPoll(input = {}) {
+        return this.client.runTriggerPoller(input);
+    }
+    runDeliveries(input = {}) {
+        return this.client.runTriggerDeliveries(input);
+    }
+}
+export class StacklinkMemoryClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    listPolicies() {
+        return this.client.request('/v1/memory/policies');
+    }
+    createPolicy(input) {
+        return this.client.request('/v1/memory/policies', { method: 'POST', body: input });
+    }
+    getPolicy(policyKey = 'default') {
+        return this.client.request(`/v1/memory/policies/${encodeURIComponent(policyKey)}`);
+    }
+    policyHistory(policyKey = 'default') {
+        return this.client.request(`/v1/memory/policies/${encodeURIComponent(policyKey)}/history`);
+    }
+    previewPolicy(input, policyKey = 'default') {
+        return this.client.request(`/v1/memory/policies/${encodeURIComponent(policyKey)}/preview`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    updatePolicy(policyKey, input) {
+        return this.client.request(`/v1/memory/policies/${encodeURIComponent(policyKey)}`, {
+            method: 'PATCH',
+            body: input,
+        });
+    }
+    deletePolicy(policyKey) {
+        return this.client.request(`/v1/memory/policies/${encodeURIComponent(policyKey)}`, { method: 'DELETE' });
+    }
+    ingest(input) {
+        return this.client.request('/v1/memory/ingest', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    ingestRich(input) {
+        return this.client.request('/v1/memory/ingest-rich', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    getRichIngest(jobId) {
+        return this.client.request(`/v1/memory/ingest-rich/${encodeURIComponent(jobId)}`);
+    }
+    recordConversationTurn(input) {
+        return this.client.request('/v1/memory/events/conversation-turn-completed', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    add(input) {
+        return this.ingest({ ...input, mode: 'exact' });
+    }
+    search(input) {
+        return this.client.request('/v1/memory/search', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    context(input) {
+        return this.client.request('/v1/memory/context', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    list(input) {
+        return this.client.request('/v1/memory/records', { query: { ...input } });
+    }
+    listForgotten(input) {
+        return this.client.request('/v1/memory/admin/forgotten-records', { query: { ...input } });
+    }
+    get(memoryId, selector) {
+        return this.client.request(`/v1/memory/records/${memoryId}`, { query: { ...selector } });
+    }
+    history(memoryId, selector) {
+        return this.client.request(`/v1/memory/records/${memoryId}/history`, { query: { ...selector } });
+    }
+    update(memoryId, input) {
+        return this.client.request(`/v1/memory/records/${memoryId}`, {
+            method: 'PATCH',
+            body: input,
+        });
+    }
+    forget(memoryId, input) {
+        return this.client.request(`/v1/memory/records/${memoryId}/forget`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    restore(memoryId, input) {
+        return this.client.request(`/v1/memory/records/${memoryId}/restore`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    erase(memoryId, input) {
+        return this.client.request(`/v1/memory/records/${memoryId}`, {
+            method: 'DELETE',
+            body: input,
+        });
+    }
+    previewErasure(memoryId, selector) {
+        return this.client.request(`/v1/memory/records/${memoryId}/erasure-preview`, {
+            method: 'POST',
+            body: selector,
+        });
+    }
+    getErasure(erasureJobId) {
+        return this.client.request(`/v1/memory/erasures/${erasureJobId}`);
+    }
+    profile(selector) {
+        return this.client.request('/v1/memory/profile', { query: { ...selector } });
+    }
+    subjectProfile(subjectId, selector) {
+        return this.client.request(`/v1/memory/subjects/${subjectId}/profile`, {
+            query: { ...selector },
+        });
+    }
+    listSubjects(input) {
+        return this.client.request('/v1/memory/subjects', { query: input });
+    }
+    eraseSubject(subjectId, input) {
+        return this.client.request(`/v1/memory/subjects/${subjectId}/erase`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    createBlock(input) {
+        return this.client.request('/v1/memory/blocks', { method: 'POST', body: input });
+    }
+    listBlocks(selector) {
+        return this.client.request('/v1/memory/blocks', { query: { ...selector } });
+    }
+    updateBlock(blockId, input) {
+        return this.client.request(`/v1/memory/blocks/${blockId}`, { method: 'PATCH', body: input });
+    }
+    revokeBlock(blockId, selector) {
+        return this.client.request(`/v1/memory/blocks/${blockId}`, { method: 'DELETE', body: selector });
+    }
+    queryGraph(input) {
+        return this.client.request('/v1/memory/graph/query', { method: 'POST', body: input });
+    }
+    createSource(input) {
+        return this.client.request('/v1/memory/sources', { method: 'POST', body: input });
+    }
+    previewConnectedSource(input) {
+        return this.client.request('/v1/memory/sources/connected/preview', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    createConnectedSource(input) {
+        return this.client.request('/v1/memory/sources/connected', {
+            method: 'POST',
+            body: input,
+        });
+    }
+    listSources(input) {
+        return this.client.request('/v1/memory/sources', { query: input });
+    }
+    getSource(bindingId) {
+        return this.client.request(`/v1/memory/sources/${bindingId}`);
+    }
+    setSourceStatus(bindingId, status) {
+        return this.updateSource(bindingId, { status });
+    }
+    updateSource(bindingId, input) {
+        return this.client.request(`/v1/memory/sources/${bindingId}`, {
+            method: 'PATCH',
+            body: input,
+        });
+    }
+    deleteSource(bindingId) {
+        return this.client.request(`/v1/memory/sources/${bindingId}`, { method: 'DELETE' });
+    }
+    replaySourceItem(bindingId, itemId) {
+        return this.client.request(`/v1/memory/sources/${bindingId}/items/${itemId}/replay`, {
+            method: 'POST',
+        });
+    }
+    listSourceDeliveries(input = {}) {
+        return this.client.request('/v1/memory/source-deliveries', { query: input });
+    }
+    replaySourceDelivery(deliveryId) {
+        return this.client.request(`/v1/memory/source-deliveries/${deliveryId}/replay`, { method: 'POST' });
+    }
+    export(input) {
+        return this.client.request('/v1/memory/exports', { method: 'POST', body: input });
+    }
+    getExport(exportId) {
+        return this.client.request(`/v1/memory/exports/${exportId}`);
+    }
+    dataManagement(input = {}) {
+        return this.client.request('/v1/memory/data-management', { query: input });
+    }
+    createLegalHold(input) {
+        return this.client.request('/v1/memory/legal-holds', { method: 'POST', body: input });
+    }
+    releaseLegalHold(holdId) {
+        return this.client.request(`/v1/memory/legal-holds/${holdId}/release`, { method: 'POST' });
+    }
+}
+export class StacklinkSessionsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.create(input);
+    }
+    use(sessionId) {
+        return this.client.use(sessionId);
+    }
+    list(query = {}) {
+        return this.client.listSessions(query);
+    }
+    get(sessionId) {
+        return this.client.getSession(sessionId);
+    }
+    update(sessionId, patch) {
+        return this.client.updateSession(sessionId, patch);
+    }
+    close(sessionId) {
+        return this.client.closeSession(sessionId);
+    }
+    fail(sessionId, input = {}) {
+        return this.client.failSession(sessionId, input);
+    }
+    metaTools(sessionId) {
+        return this.client.getSessionMetaTools(sessionId);
+    }
+    toolkits(sessionId) {
+        return this.client.request(`/v1/sessions/${sessionId}/toolkits`);
+    }
+    streamEvents(sessionId, input = {}) {
+        return this.client.requestRaw(`/v1/sessions/${sessionId}/events/stream`, {
+            headers: {
+                accept: 'text/event-stream',
+            },
+            query: {
+                after: input.after,
+                eventType: input.eventTypes,
+                limit: input.limit,
+                pollIntervalMs: input.pollIntervalMs,
+            },
+        });
+    }
+    listRouterFacts(sessionId, query = {}) {
+        return this.client.listSessionRouterFacts(sessionId, query);
+    }
+    listConnectionEvents(sessionId) {
+        return this.client.listSessionConnectionEvents(sessionId);
+    }
+    workbench(sessionId) {
+        return this.client.getSessionWorkbench(sessionId);
+    }
+}
+export class StacklinkLogsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    summary() {
+        return this.client.getLogSummary();
+    }
+    listRequests(query = {}) {
+        return this.client.listRequestLogs(query);
+    }
+    getRequest(logId) {
+        return this.client.getRequestLog(logId);
+    }
+    listTools(query = {}) {
+        return this.client.listToolLogs(query);
+    }
+    getTool(logId) {
+        return this.client.getToolLog(logId);
+    }
+    listTriggers(query = {}) {
+        return this.client.listTriggerLogs(query);
+    }
+    getTrigger(logId) {
+        return this.client.getTriggerLog(logId);
+    }
+    listWebhookDeliveries(query = {}) {
+        return this.client.listWebhookDeliveries(query);
+    }
+    getWebhookDelivery(deliveryId) {
+        return this.client.getWebhookDeliveryLog(deliveryId);
+    }
+    retryWebhookDelivery(deliveryId, input = {}) {
+        return this.client.retryWebhookDelivery(deliveryId, input);
+    }
+    redriveDeadLetters(input = {}) {
+        return this.client.redriveDeadLetterWebhookDeliveries(input);
+    }
+    replayProviderEvent(eventId) {
+        return this.client.replayProviderEvent(eventId);
+    }
+}
+export class StacklinkApiKeysClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.createApiKey(input);
+    }
+    delete(apiKeyId) {
+        return this.client.deleteApiKey(apiKeyId);
+    }
+}
+export class StacklinkBillingClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    getSubscription() {
+        return this.client.getSubscription();
+    }
+    listPlans() {
+        return this.client.listBillingPlans();
+    }
+    getUsage() {
+        return this.client.getUsage();
+    }
+    listUsageEvents(query = {}) {
+        return this.client.listUsageEvents(query);
+    }
+    createCheckout(input) {
+        return this.client.createBillingCheckout(input);
+    }
+    createPortal(input = {}) {
+        return this.client.createBillingPortal(input);
+    }
+    setWorkspacePlanForProject(projectId, input) {
+        return this.client.setWorkspaceSubscriptionPlanForProject(projectId, input);
+    }
+}
+export class StacklinkConnectedAccountsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(tenantId) {
+        return this.client.listConnectedAccounts(tenantId);
+    }
+    create(input) {
+        return this.client.createConnectedAccount(input);
+    }
+    get(accountId) {
+        return this.client.getConnectedAccount(accountId);
+    }
+    listTools(accountId, input = {}) {
+        return this.client.listConnectedAccountTools(accountId, input);
+    }
+    listResources(accountId) {
+        return this.client.listConnectedAccountResources(accountId);
+    }
+    refreshResources(accountId) {
+        return this.client.refreshConnectedAccountResources(accountId);
+    }
+    resolveResource(accountId, input) {
+        return this.client.resolveConnectedAccountResource(accountId, input);
+    }
+    update(accountId, patch) {
+        return this.client.updateConnectedAccount(accountId, patch);
+    }
+    enable(accountId) {
+        return this.client.enableConnectedAccount(accountId);
+    }
+    disable(accountId) {
+        return this.client.disableConnectedAccount(accountId);
+    }
+    refresh(accountId) {
+        return this.client.refreshConnectedAccount(accountId);
+    }
+    validate(accountId) {
+        return this.client.validateConnectedAccount(accountId);
+    }
+    delete(accountId) {
+        return this.client.deleteConnectedAccount(accountId);
+    }
+}
+export class StacklinkAuthConfigsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list(query = {}) {
+        return this.client.listAuthConfigs(query);
+    }
+    create(input) {
+        return this.client.createAuthConfig(input);
+    }
+    get(authConfigId) {
+        return this.client.getAuthConfig(authConfigId);
+    }
+    update(authConfigId, patch) {
+        return this.client.updateAuthConfig(authConfigId, patch);
+    }
+    enable(authConfigId) {
+        return this.client.enableAuthConfig(authConfigId);
+    }
+    disable(authConfigId) {
+        return this.client.disableAuthConfig(authConfigId);
+    }
+    delete(authConfigId) {
+        return this.client.deleteAuthConfig(authConfigId);
+    }
+}
+export class StacklinkToolkitsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    list() {
+        return this.client.listProviders();
+    }
+    listProject(query = {}) {
+        return this.client.listProjectProviders(query);
+    }
+    listTools(providerKey) {
+        return this.client.listProviderTools(providerKey);
+    }
+}
+export class StacklinkProviderToolsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    search(input) {
+        return this.client.searchTools(input);
+    }
+    schemas(input) {
+        return this.client.getToolSchemas(input);
+    }
+    runtimeContracts(input) {
+        return this.client.getRuntimeToolContracts(input);
+    }
+    execute(input) {
+        return this.client.executeTool(input);
+    }
+    executeBatch(input) {
+        return this.client.executeToolsBatch(input);
+    }
+}
+export class StacklinkSessionMemoryClient {
+    memoryClient;
+    sessionId;
+    constructor(memoryClient, sessionId) {
+        this.memoryClient = memoryClient;
+        this.sessionId = sessionId;
+    }
+    add(input) {
+        return this.memoryClient.add({ ...input, sessionId: this.sessionId });
+    }
+    ingest(input) {
+        return this.memoryClient.ingest({ ...input, sessionId: this.sessionId });
+    }
+    ingestRich(input) {
+        return this.memoryClient.ingestRich({ ...input, sessionId: this.sessionId });
+    }
+    getRichIngest(jobId) {
+        return this.memoryClient.getRichIngest(jobId);
+    }
+    recordConversationTurn(input) {
+        return this.memoryClient.recordConversationTurn({ ...input, sessionId: this.sessionId });
+    }
+    search(input) {
+        return this.memoryClient.search({ ...input, sessionId: this.sessionId });
+    }
+    context(input) {
+        return this.memoryClient.context({ ...input, sessionId: this.sessionId });
+    }
+    recall(input) {
+        return this.context(input);
+    }
+    profile() {
+        return this.memoryClient.profile({ sessionId: this.sessionId });
+    }
+    get(memoryId) {
+        return this.memoryClient.get(memoryId, { sessionId: this.sessionId });
+    }
+    history(memoryId) {
+        return this.memoryClient.history(memoryId, { sessionId: this.sessionId });
+    }
+    update(memoryId, patch) {
+        return this.memoryClient.update(memoryId, { sessionId: this.sessionId, patch });
+    }
+    forget(memoryId, reason) {
+        return this.memoryClient.forget(memoryId, {
+            sessionId: this.sessionId,
+            ...(reason ? { reason } : {}),
+        });
+    }
+    restore(memoryId, reason) {
+        return this.memoryClient.restore(memoryId, {
+            sessionId: this.sessionId,
+            ...(reason ? { reason } : {}),
+        });
+    }
+}
+export class StacklinkWorkbenchRun {
+    client;
+    platformSessionId;
+    response;
+    executionId;
+    executionKind;
+    constructor(client, platformSessionId, response) {
+        this.client = client;
+        this.platformSessionId = platformSessionId;
+        this.response = response;
+        this.executionId = response.executionId;
+        this.executionKind = response.executionKind;
+    }
+    async *events(input = {}) {
+        let afterSequence;
+        while (true) {
+            const page = await this.client.readExecutionEvents({
+                sessionId: this.platformSessionId,
+                executionKind: this.executionKind,
+                executionId: this.executionId,
+                afterSequence,
+                limit: input.limit ?? 200,
+            });
+            for (const event of page.events) {
+                yield event;
+                if (isSdkRecord(event) && (typeof event.sequence === 'string' || typeof event.sequence === 'number')) {
+                    afterSequence = String(event.sequence);
+                }
+            }
+            if (page.hasMore) {
+                if (!page.nextCursor)
+                    throw new Error('Execution event page reported hasMore without nextCursor.');
+                afterSequence = page.nextCursor;
+                continue;
+            }
+            const state = await this.client.getExecution({
+                sessionId: this.platformSessionId,
+                executionKind: this.executionKind,
+                executionId: this.executionId,
+            });
+            if (isTerminalSdkExecution(state.execution))
+                return;
+            await sleep(input.pollIntervalMs ?? 500);
+        }
+    }
+    wait(input = {}) {
+        return this.client.waitForExecution({
+            sessionId: this.platformSessionId,
+            executionKind: this.executionKind,
+            executionId: this.executionId,
+            ...input,
+        });
+    }
+    cancel(reason) {
+        return this.client.cancelExecution({
+            sessionId: this.platformSessionId,
+            executionKind: this.executionKind,
+            executionId: this.executionId,
+            reason,
+        });
+    }
+}
+export class StacklinkWorkbenchFiles {
+    client;
+    platformSessionId;
+    workbenchSessionId;
+    constructor(client, platformSessionId, workbenchSessionId) {
+        this.client = client;
+        this.platformSessionId = platformSessionId;
+        this.workbenchSessionId = workbenchSessionId;
+    }
+    async list() {
+        return this.client.listWorkbenchFiles({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+        });
+    }
+    async read(path) {
+        return this.client.readWorkbenchFile({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            path,
+        });
+    }
+    async upload(input) {
+        return this.client.uploadWorkbenchFile({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            ...input,
+        });
+    }
+    async uploadLarge(input) {
+        return this.client.uploadWorkbenchFileDirect({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            ...input,
+        });
+    }
+    async download(path) {
+        return this.client.downloadWorkbenchFile({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            path,
+        });
+    }
+    async delete(path) {
+        return this.client.deleteWorkbenchFile({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            path,
+        });
+    }
+}
+export class StacklinkWorkbenchRuns {
+    client;
+    platformSessionId;
+    workbenchSessionId;
+    constructor(client, platformSessionId, workbenchSessionId) {
+        this.client = client;
+        this.platformSessionId = platformSessionId;
+        this.workbenchSessionId = workbenchSessionId;
+    }
+    async list(seriesId, cursor, limit) {
+        return this.client.listWorkbenchRunDefinitions({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            ...(seriesId ? { seriesId } : {}),
+            ...(cursor ? { cursor } : {}),
+            ...(limit ? { limit } : {}),
+        });
+    }
+    get(runDefinitionId) {
+        return this.client.getWorkbenchRunDefinition({
+            sessionId: this.platformSessionId,
+            runDefinitionId,
+        });
+    }
+    update(runDefinitionId, input) {
+        return this.client.updateWorkbenchRunDefinition({
+            sessionId: this.platformSessionId,
+            runDefinitionId,
+            ...input,
+        });
+    }
+    async save(input) {
+        return this.client.createWorkbenchRunDefinition({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            ...input,
+        });
+    }
+    replay(runDefinitionId, input) {
+        return this.client.replayWorkbenchRunDefinition({
+            sessionId: this.platformSessionId,
+            runDefinitionId,
+            ...input,
+        });
+    }
+    publish(runDefinitionId, expectedPublishedVersion) {
+        return this.client.publishWorkbenchRunDefinition({
+            sessionId: this.platformSessionId,
+            runDefinitionId,
+            expectedPublishedVersion,
+        });
+    }
+    rollback(runDefinitionId, expectedPublishedVersion) {
+        return this.client.rollbackWorkbenchRunDefinition({
+            sessionId: this.platformSessionId,
+            runDefinitionId,
+            expectedPublishedVersion,
+        });
+    }
+}
+export class StacklinkWorkbenchArtifacts {
+    client;
+    platformSessionId;
+    workbenchSessionId;
+    constructor(client, platformSessionId, workbenchSessionId) {
+        this.client = client;
+        this.platformSessionId = platformSessionId;
+        this.workbenchSessionId = workbenchSessionId;
+    }
+    async list() {
+        return this.client.listWorkbenchArtifacts({ workbenchSessionId: await this.workbenchSessionId() });
+    }
+    async promote(input) {
+        return this.client.promoteWorkbenchArtifact({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            ...input,
+        });
+    }
+    downloadUrl(artifactId) {
+        return this.client.getWorkbenchArtifactDownloadUrl(artifactId);
+    }
+    download(artifactId) {
+        return this.client.downloadWorkbenchArtifact(artifactId);
+    }
+    async delete(artifactId, path) {
+        return this.client.deleteWorkbenchArtifact({
+            sessionId: this.platformSessionId,
+            workbenchSessionId: await this.workbenchSessionId(),
+            artifactId,
+            path,
+        });
+    }
+}
+export class StacklinkSessionSandbox {
+    client;
+    platformSessionId;
+    files;
+    runs;
+    artifacts;
+    activeWorkbenchSessionId;
+    constructor(client, platformSessionId) {
+        this.client = client;
+        this.platformSessionId = platformSessionId;
+        this.files = new StacklinkWorkbenchFiles(client, platformSessionId, () => this.ensureWorkbenchSession());
+        this.runs = new StacklinkWorkbenchRuns(client, platformSessionId, () => this.ensureWorkbenchSession());
+        this.artifacts = new StacklinkWorkbenchArtifacts(client, platformSessionId, () => this.ensureWorkbenchSession());
+    }
+    async use(workbenchSessionId, input = {}) {
+        const response = await this.client.useWorkbenchSession({
+            sessionId: this.platformSessionId,
+            workbenchSessionId,
+            ...input,
+        });
+        this.activeWorkbenchSessionId = response.workbenchSession.id;
+        return response;
+    }
+    async run(input, options = {}) {
+        const workbenchSessionId = input.workbenchSessionId ?? await this.ensureWorkbenchSession();
+        const response = await this.client.runWorkbench({
+            ...input,
+            sessionId: this.platformSessionId,
+            workbenchSessionId,
+            operation: 'run_code',
+        }, options);
+        this.activeWorkbenchSessionId = response.workbenchSession.id;
+        return new StacklinkWorkbenchRun(this.client, this.platformSessionId, response);
+    }
+    async bash(input, options = {}) {
+        const workbenchSessionId = input.workbenchSessionId ?? await this.ensureWorkbenchSession();
+        const response = await this.client.runWorkbenchBash({
+            ...input,
+            sessionId: this.platformSessionId,
+            workbenchSessionId,
+        }, options);
+        this.activeWorkbenchSessionId = response.workbenchSession.id;
+        return new StacklinkWorkbenchRun(this.client, this.platformSessionId, response);
+    }
+    async destroy() {
+        const workbenchSessionId = await this.ensureWorkbenchSession();
+        return this.client.destroyWorkbenchSession({
+            sessionId: this.platformSessionId,
+            workbenchSessionId,
+        });
+    }
+    async delete() {
+        const workbenchSessionId = await this.ensureWorkbenchSession();
+        const result = await this.client.deleteWorkbenchSession({
+            sessionId: this.platformSessionId,
+            workbenchSessionId,
+        });
+        this.activeWorkbenchSessionId = undefined;
+        return result;
+    }
+    async ensureWorkbenchSession() {
+        if (this.activeWorkbenchSessionId)
+            return this.activeWorkbenchSessionId;
+        const response = await this.use();
+        return response.workbenchSession.id;
+    }
+}
+export class ToolRouterSession {
+    client;
+    id;
+    tenantId;
+    mcp;
+    memory;
+    sandbox;
+    contractVersion;
+    toolDefinitions;
+    constructor(client, id, tenantId, mcp, contractVersion = 'unknown', toolDefinitions = []) {
+        this.client = client;
+        this.id = id;
+        this.tenantId = tenantId;
+        this.mcp = mcp;
+        this.contractVersion = contractVersion;
+        this.toolDefinitions = [...toolDefinitions];
+        this.memory = new StacklinkSessionMemoryClient(client.memory, id);
+        this.sandbox = new StacklinkSessionSandbox(client, id);
+    }
+    async get() {
+        return this.client.getSession(this.id);
+    }
+    async mcpRequest(input, options = {}) {
+        return this.client.mcpSessionRequest(this.id, input, options);
+    }
+    async mcpRequestStream(input, options = {}) {
+        return this.client.mcpSessionRequestStream(this.id, input, options);
+    }
+    async callMcpTool(name, args) {
+        return this.client.callSessionMcpTool(this.id, name, args);
+    }
+    mcpConnection() {
+        if (!this.mcp) {
+            throw new Error('This Stacklink session does not include an MCP connection descriptor.');
+        }
+        return this.client.sessionMcpConnection(this.mcp);
+    }
+    async update(patch) {
+        const response = await this.client.updateSession(this.id, patch);
+        this.client.clearCache(`session:${this.id}:`);
+        const projection = await this.client.getSessionMetaTools(this.id);
+        this.contractVersion = projection.contractVersion;
+        this.toolDefinitions = [...projection.tools];
+        return response;
+    }
+    toolContractVersion() {
+        return this.contractVersion;
+    }
+    toolRegistry() {
+        return this.toolDefinitions.map((definition) => ({
+            ...definition,
+            inputSchema: { ...definition.inputSchema },
+        }));
+    }
+    async close() {
+        return this.client.closeSession(this.id);
+    }
+    async routerFacts(query = {}) {
+        return this.client.listSessionRouterFacts(this.id, query);
+    }
+    async connectionEvents() {
+        return this.client.listSessionConnectionEvents(this.id);
+    }
+    async trace(query = {}) {
+        return this.client.getSessionTrace(this.id, query);
+    }
+    async configHistory(query = {}) {
+        return this.client.getSessionConfigHistory(this.id, query);
+    }
+    async workbenchActivity() {
+        return this.client.getSessionWorkbench(this.id);
+    }
+    async toolkits() {
+        const response = await this.client.cachedDiscoveryRequest(`session:${this.id}:toolkits`, this.client.discoveryCacheTtl('toolkits'), undefined, () => this.client.request(`/v1/sessions/${this.id}/toolkits`));
+        return response.toolkits;
+    }
+    async authorize(providerKey, input = {}) {
+        const response = await this.client.request(`/v1/sessions/${this.id}/connections/authorize`, {
+            method: 'POST',
+            body: {
+                providerKey,
+                callbackUrl: input.callbackUrl,
+                authConfigId: input.authConfigId,
+                authMode: input.authMode,
+                metadata: input.metadata ?? {},
+            },
+        });
+        if (!response.authorization) {
+            throw new Error('Stacklink did not return a connection authorization.');
+        }
+        return new StacklinkConnectionRequest(this.client, response.authorization);
+    }
+    async waitForConnections(connectionRequestIds, timeoutMs = 120_000, intervalMs = 2000) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= timeoutMs) {
+            const connectionRequests = await Promise.all(connectionRequestIds.map(async (requestId) => {
+                const response = await this.client.request(`/v1/connection-requests/${requestId}`);
+                return response.connectionRequest;
+            }));
+            const statuses = connectionRequests.map((request) => request?.status);
+            if (statuses.every((status) => status === 'completed')) {
+                return { status: 'completed', connectionRequests };
+            }
+            const terminalFailure = connectionRequests.find((request) => (request?.status === 'failed'
+                || request?.status === 'expired'
+                || request?.status === 'cancelled'));
+            if (terminalFailure) {
+                throw new Error(`Stacklink connection ended with status ${terminalFailure.status}.`);
+            }
+            await sleep(intervalMs);
+        }
+        throw new Error('Timed out waiting for Stacklink connections.');
+    }
+    async connectedAccounts() {
+        const response = await this.client.request('/v1/connections', {
+            query: { tenantId: this.tenantId },
+        });
+        return response.connections;
+    }
+    async getConnectedAccount(accountId) {
+        const response = await this.client.request(`/v1/connections/${accountId}`);
+        return response.account;
+    }
+    async updateConnectedAccount(accountId, patch) {
+        const response = await this.client.request(`/v1/connections/${accountId}`, {
+            method: 'PATCH',
+            body: patch,
+        });
+        this.client.clearCache(`session:${this.id}:`);
+        return response.account;
+    }
+    async enableConnectedAccount(accountId) {
+        const response = await this.client.request(`/v1/connections/${accountId}/enable`, {
+            method: 'POST',
+        });
+        this.client.clearCache(`session:${this.id}:`);
+        return response.account;
+    }
+    async disableConnectedAccount(accountId) {
+        const response = await this.client.request(`/v1/connections/${accountId}/disable`, {
+            method: 'POST',
+        });
+        this.client.clearCache(`session:${this.id}:`);
+        return response.account;
+    }
+    async refreshConnectedAccount(accountId) {
+        const response = await this.client.request(`/v1/connections/${accountId}/refresh`, {
+            method: 'POST',
+        });
+        this.client.clearCache(`session:${this.id}:`);
+        return response.account;
+    }
+    async validateConnectedAccount(accountId) {
+        return this.client.request(`/v1/connections/${accountId}/validate`, {
+            method: 'POST',
+        });
+    }
+    async deleteConnectedAccount(accountId) {
+        const response = await this.client.request(`/v1/connections/${accountId}`, {
+            method: 'DELETE',
+        });
+        this.client.clearCache(`session:${this.id}:`);
+        return response.account;
+    }
+    async connectedAccountSecrets(accountId) {
+        const response = await this.client.request(`/v1/connections/${accountId}/secrets`);
+        return response.secrets;
+    }
+    async connectedAccountResources(accountId) {
+        return this.client.listConnectedAccountResources(accountId);
+    }
+    async refreshConnectedAccountResources(accountId) {
+        const response = await this.client.refreshConnectedAccountResources(accountId);
+        this.client.clearCache(`session:${this.id}:`);
+        return response;
+    }
+    async searchTools(input = {}) {
+        const searchInput = {
+            responseMode: 'compact',
+            includeSchemas: false,
+            includeRelatedTools: false,
+            includeExecutionPlan: false,
+            ...input,
+        };
+        return this.client.cachedDiscoveryRequest(`session:${this.id}:search:${stableSdkStringify(withoutCacheControl(searchInput))}`, this.client.discoveryCacheTtl('search'), searchInput, () => this.client.request(`/v1/sessions/${this.id}/tools/search`, {
+            method: 'POST',
+            body: discoveryServerBody(searchInput),
+        }));
+    }
+    async getToolSchemas(toolKeys, input = {}) {
+        return this.client.cachedDiscoveryRequest(`session:${this.id}:schemas:${stableSdkStringify({
+            toolKeys: [...toolKeys].sort(),
+            includePlanned: input.includePlanned === true,
+        })}`, this.client.discoveryCacheTtl('schemas'), input, () => this.client.request(`/v1/sessions/${this.id}/tools/schemas`, {
+            method: 'POST',
+            body: {
+                toolKeys,
+                includePlanned: input.includePlanned,
+                ...(input.cache === 'bypass' ? { cache: 'bypass' } : {}),
+            },
+        }));
+    }
+    async prepareRuntimeTools(input = {}) {
+        return this.client.request(`/v1/sessions/${this.id}/tools/runtime-contracts`, {
+            method: 'POST',
+            body: input,
+        });
+    }
+    async prepareTools(input) {
+        const limitPerIntent = input.limitPerIntent ?? 5;
+        const search = await this.searchTools({
+            cache: input.cache,
+            responseMode: 'compact',
+            includeSchemas: false,
+            includeRelatedTools: false,
+            includeExecutionPlan: false,
+            queries: input.intents.map((intent) => ({
+                query: intent,
+                limit: limitPerIntent,
+                ...(input.toolkitKey ? { toolkitKey: input.toolkitKey } : {}),
+                ...(input.capability ? { capability: input.capability } : {}),
+            })),
+            includePlanned: input.includePlanned === true,
+            model: input.model,
+            limit: Math.max(limitPerIntent, input.intents.length * limitPerIntent),
+        });
+        const toolKeys = uniqueSdkStrings(search.tools.map((tool) => tool.key));
+        const schemaResponse = input.includeSchemas === false || toolKeys.length === 0
+            ? { tools: [] }
+            : await this.getToolSchemas(toolKeys, {
+                cache: input.cache,
+                includePlanned: input.includePlanned,
+            });
+        return {
+            tools: search.tools,
+            schemas: schemaResponse.tools,
+            toolKeys,
+            search,
+        };
+    }
+    async searchKnowledge(input = {}) {
+        return this.client.searchKnowledge({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getKnowledgeCapabilities(input = {}) {
+        return this.client.getKnowledgeCapabilities({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async lookupKnowledgeCitation(input = {}) {
+        return this.client.lookupKnowledgeCitation({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getKnowledgeAmendmentTrail(input = {}) {
+        return this.client.getKnowledgeAmendmentTrail({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async verifyKnowledgeEvidence(input = {}) {
+        return this.client.verifyKnowledgeEvidence({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async verifyKnowledgeAnswer(input) {
+        return this.client.verifyKnowledgeAnswer({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getGstComplianceRule(input = {}) {
+        return this.client.getGstComplianceRule({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getGstDueDateRule(input) {
+        return this.client.getGstDueDateRule({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async calculateGstDueDate(input) {
+        return this.client.calculateGstDueDate({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getGstLateFeeRule(input) {
+        return this.client.getGstLateFeeRule({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async calculateGstLateFee(input) {
+        return this.client.calculateGstLateFee({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getGstInterestRule(input = {}) {
+        return this.client.getGstInterestRule({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async calculateGstInterest(input) {
+        return this.client.calculateGstInterest({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async lookupGstHsnSacRate(input) {
+        return this.client.lookupGstHsnSacRate({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async checkGstRcm(input) {
+        return this.client.checkGstRcm({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getGstNoticeRule(input) {
+        return this.client.getGstNoticeRule({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async getGstAppealStageRule(input) {
+        return this.client.getGstAppealStageRule({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async executeTool(input, options = {}) {
+        return this.client.request(`/v1/sessions/${this.id}/tools/execute`, {
+            method: 'POST',
+            body: input,
+            ...options,
+        });
+    }
+    async executeToolsBatch(input, options = {}) {
+        return this.client.request(`/v1/sessions/${this.id}/tools/execute-batch`, {
+            method: 'POST',
+            body: input,
+            ...options,
+        });
+    }
+    async runWorkbench(input, options = {}) {
+        return this.client.runWorkbench({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async destroyWorkbenchSession(input, options = {}) {
+        return this.client.destroyWorkbenchSession({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async deleteWorkbenchSession(input) {
+        return this.client.deleteWorkbenchSession({
+            ...input,
+            sessionId: this.id,
+        });
+    }
+    async runWorkbenchBash(input, options = {}) {
+        return this.client.runWorkbenchBash({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async listExecutions(input = {}, options = {}) {
+        return this.client.listExecutions({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async getExecution(input, options = {}) {
+        return this.client.getExecution({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async readExecutionEvents(input, options = {}) {
+        return this.client.readExecutionEvents({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async waitForExecution(input, options = {}) {
+        return this.client.waitForExecution({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async cancelExecution(input, options = {}) {
+        return this.client.cancelExecution({
+            ...input,
+            sessionId: this.id,
+        }, options);
+    }
+    async streamEvents(input = {}) {
+        return this.client.requestRaw(`/v1/sessions/${this.id}/events/stream`, {
+            headers: {
+                accept: 'text/event-stream',
+            },
+            query: {
+                after: input.after,
+                eventType: input.eventTypes,
+                limit: input.limit === undefined ? undefined : String(input.limit),
+                pollIntervalMs: input.pollIntervalMs === undefined ? undefined : String(input.pollIntervalMs),
+            },
+        });
+    }
+    tools() {
+        return Object.fromEntries(this.toolDefinitions.map((definition) => [
+            definition.name,
+            {
+                description: definition.description,
+                parameters: definition.inputSchema,
+                execute: async (input) => unwrapMcpToolResult(await this.callMcpTool(definition.name, input)),
+            },
+        ]));
+    }
+}
+export { ToolRouterSession as StacklinkSession };
+export class StacklinkConnectionRequest {
+    client;
+    id;
+    providerKey;
+    status;
+    phase;
+    nextAction;
+    redirectUrl;
+    expiresAt;
+    authModes;
+    authRequirements;
+    constructor(client, input) {
+        this.client = client;
+        this.id = input.id;
+        this.providerKey = input.providerKey;
+        this.status = input.status;
+        this.phase = input.phase;
+        this.nextAction = input.nextAction;
+        this.redirectUrl = input.redirectUrl;
+        this.expiresAt = input.expiresAt;
+        this.authModes = input.authModes;
+        this.authRequirements = input.authRequirements ?? [];
+    }
+    async getStatus() {
+        const response = await this.client.request(`/v1/connection-requests/${this.id}`);
+        return response.connectionRequest;
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            providerKey: this.providerKey,
+            status: this.status,
+            phase: this.phase,
+            nextAction: this.nextAction,
+            redirectUrl: this.redirectUrl,
+            expiresAt: this.expiresAt,
+            authModes: this.authModes,
+            authRequirements: this.authRequirements,
+        };
+    }
+    async waitForConnection(timeoutMs = 120_000, intervalMs = 2000) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt <= timeoutMs) {
+            const connectionRequest = await this.getStatus();
+            if (connectionRequest?.status === 'completed') {
+                return connectionRequest.connectedAccount;
+            }
+            if (connectionRequest?.status === 'failed'
+                || connectionRequest?.status === 'expired'
+                || connectionRequest?.status === 'cancelled') {
+                throw new Error(`Stacklink connection ended with status ${connectionRequest.status}.`);
+            }
+            await sleep(intervalMs);
+        }
+        throw new Error('Timed out waiting for Stacklink connection.');
+    }
+}
+function isSdkRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function unwrapMcpToolResult(response) {
+    if (!isSdkRecord(response))
+        return response;
+    if (isSdkRecord(response.error)) {
+        const message = typeof response.error.message === 'string'
+            ? response.error.message
+            : 'Stacklink MCP tool call failed.';
+        const code = typeof response.error.code === 'string' || typeof response.error.code === 'number'
+            ? String(response.error.code)
+            : undefined;
+        throw new StacklinkApiError(message, 400, code, response.error.data);
+    }
+    const result = response.result;
+    if (!isSdkRecord(result))
+        return result;
+    if (result.isError === true) {
+        const errorText = Array.isArray(result.content)
+            ? result.content
+                .filter(isSdkRecord)
+                .filter((item) => item.type === 'text' && typeof item.text === 'string')
+                .map((item) => String(item.text))
+                .join('\n')
+            : '';
+        throw new StacklinkApiError(errorText || 'Stacklink MCP tool call failed.', 400, 'mcp_tool_error', result);
+    }
+    if ('structuredContent' in result)
+        return result.structuredContent;
+    if (!Array.isArray(result.content))
+        return result;
+    const textItems = result.content
+        .filter(isSdkRecord)
+        .filter((item) => item.type === 'text' && typeof item.text === 'string')
+        .map((item) => String(item.text));
+    if (textItems.length !== 1)
+        return result;
+    try {
+        return JSON.parse(textItems[0]);
+    }
+    catch {
+        return textItems[0];
+    }
+}
+function isTerminalSdkExecution(value) {
+    if (!isSdkRecord(value))
+        return false;
+    const status = value.status;
+    return status === 'completed'
+        || status === 'failed'
+        || status === 'cancelled'
+        || status === 'timed_out';
+}
+//# sourceMappingURL=index.js.map