@agnt5/sdk 0.2.1

package/dist/client.js

@@ -0,0 +1,757 @@
+/**
+ * AGNT5 Client SDK for invoking components
+ */
+import { RunError, TimeoutError, ValidationError, createErrorFromResponse, } from './errors.js';
+import { BatchResult, BatchStatusResult } from './batch.js';
+import { EvalResponse, BatchEvalResult, BatchEvalItemResult, normalizeBatchEvalItems, normalizeScorerSpecs } from './eval.js';
+/**
+ * Typed response from run(), getResult(), waitForResult().
+ *
+ * Follows httpx-style patterns with isSuccess, isPending, isError, raiseForStatus().
+ *
+ * @example
+ * ```typescript
+ * const response = await client.run('greet', { name: 'Alice' });
+ * if (response.isSuccess) {
+ *   console.log(response.output);
+ * } else {
+ *   response.raiseForStatus();
+ * }
+ * ```
+ */
+export class RunResponse {
+    constructor(raw) {
+        this.runId = raw.run_id || raw.runId || '';
+        this.statusCode = raw.status_code ?? (raw.status === 'completed' ? 200 : raw.status === 'failed' ? 500 : 202);
+        this.status = raw.status || 'unknown';
+        const nestedOutput = raw.result?.output;
+        this.output = (raw.output ??
+            raw.output_data ??
+            nestedOutput?.output_data ??
+            nestedOutput);
+        this.durationMs = raw.duration_ms;
+        this.traceId = raw.trace_id;
+        this.component = raw.component;
+        this.createdAt = raw.created_at;
+        this.startedAt = raw.started_at;
+        this.completedAt = raw.completed_at;
+        this.failedAt = raw.failed_at;
+        this.sessionId = raw.session_id;
+        this.metadata = raw.metadata;
+        // Parse error — could be a string or a structured object
+        if (raw.error || raw.error_message) {
+            if (typeof raw.error === 'string') {
+                this.error = { code: raw.error_code || 'EXECUTION_FAILED', message: raw.error };
+            }
+            else if (typeof raw.error === 'object') {
+                this.error = {
+                    code: raw.error.code || raw.error_code || 'EXECUTION_FAILED',
+                    message: raw.error.message || String(raw.error),
+                    details: raw.error.details,
+                };
+            }
+            else if (raw.error_message) {
+                this.error = { code: raw.error_code || 'EXECUTION_FAILED', message: raw.error_message };
+            }
+        }
+    }
+    /** True if the run completed successfully */
+    get isSuccess() {
+        return this.status === 'completed' && !this.error;
+    }
+    /** True if the run is still in progress */
+    get isPending() {
+        return ['enqueued', 'started', 'running', 'paused', 'awaiting_input'].includes(this.status);
+    }
+    /** True if the run failed, was cancelled, or timed out */
+    get isError() {
+        return ['failed', 'cancelled', 'timeout'].includes(this.status) || this.statusCode === 500;
+    }
+    /** Execution duration as milliseconds (undefined if not available) */
+    get elapsed() {
+        return this.durationMs;
+    }
+    /** Throw RunError if the run failed */
+    raiseForStatus() {
+        if (this.isError) {
+            if (this.error) {
+                throw new RunError(this.error.message, this.runId, this.status, this.error.code);
+            }
+            throw new RunError(`Run failed with status: ${this.status}`, this.runId, this.status);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Entity proxy
+// ---------------------------------------------------------------------------
+/**
+ * Proxy for calling methods on durable entities
+ */
+export class EntityProxy {
+    constructor(client, entityType, key) {
+        this.client = client;
+        this.entityType = entityType;
+        this.key = key;
+    }
+    async call(method, args = {}) {
+        const url = `${this.client['gatewayUrl']}/v1/entity/${this.entityType}/${this.key}/${method}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.client['buildHeaders'](),
+            body: JSON.stringify(args),
+            signal: AbortSignal.timeout(this.client['timeout']),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json().catch(() => ({})));
+            throw new RunError(errorData.error || `HTTP ${response.status}: Entity method call failed`, errorData.runId);
+        }
+        const data = (await response.json());
+        if (data.status === 'failed') {
+            const errMsg = typeof data.error === 'string' ? data.error : data.error?.message || 'Unknown error';
+            throw new RunError(errMsg, data.run_id || data.runId);
+        }
+        return data.output;
+    }
+}
+// ---------------------------------------------------------------------------
+// Client
+// ---------------------------------------------------------------------------
+/**
+ * Client for invoking AGNT5 components
+ *
+ * @example
+ * ```typescript
+ * import { Client } from '@agnt5/sdk';
+ *
+ * // Local development
+ * const client = new Client({ gatewayUrl: 'http://localhost:34181' });
+ *
+ * // Production with API key
+ * const client = new Client({
+ *   gatewayUrl: 'https://api.agnt5.com',
+ *   apiKey: 'agnt5_sk_...',
+ * });
+ *
+ * // Synchronous execution with typed response
+ * const response = await client.run('greet', { name: 'Alice' });
+ * if (response.isSuccess) {
+ *   console.log(response.output);
+ * }
+ *
+ * // Async execution
+ * const submit = await client.submit('long_task', { data: '...' });
+ * const result = await client.waitForResult(submit.runId);
+ *
+ * // Stream typed events
+ * for await (const event of client.events(runId)) {
+ *   console.log(event.eventType, event.data);
+ * }
+ * ```
+ */
+export class Client {
+    constructor(options = {}) {
+        const env = typeof process !== 'undefined' ? process.env : undefined;
+        this.gatewayUrl = (options.gatewayUrl || env?.AGNT5_GATEWAY_URL || 'http://localhost:34181').replace(/\/$/, '');
+        this.apiKey = options.apiKey || env?.AGNT5_API_KEY;
+        this.tenantId = options.tenantId || env?.AGNT5_PROJECT_ID || env?.AGNT5_TENANT_ID;
+        this.deploymentId = options.deploymentId || env?.AGNT5_DEPLOYMENT_ID;
+        this.timeout = options.timeout || 30000;
+        this.maxRetries = options.maxRetries ?? 3;
+        this.retryDelayMs = options.retryDelayMs || 1000;
+    }
+    /**
+     * Build request headers with authentication and routing. `tenantOverride`
+     * wins over the client-level `tenantId` when set.
+     */
+    buildHeaders(extra, tenantOverride) {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['X-API-KEY'] = this.apiKey;
+        }
+        const effectiveTenant = tenantOverride ?? this.tenantId;
+        if (effectiveTenant) {
+            headers['X-Tenant-ID'] = effectiveTenant;
+        }
+        if (this.deploymentId) {
+            headers['X-Deployment-ID'] = this.deploymentId;
+        }
+        if (extra) {
+            Object.assign(headers, extra);
+        }
+        return headers;
+    }
+    /**
+     * Retry failed requests with exponential backoff
+     */
+    async withRetry(operation, maxRetries) {
+        const retries = maxRetries ?? this.maxRetries;
+        let lastError;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on these errors
+                if (error instanceof ValidationError ||
+                    error instanceof RunError ||
+                    error instanceof TimeoutError) {
+                    throw error;
+                }
+                if (attempt === retries)
+                    break;
+                const delay = this.retryDelayMs * Math.pow(2, attempt);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Execute a component synchronously and wait for the result.
+     *
+     * Returns a typed RunResponse with metadata (traceId, durationMs, status).
+     */
+    async run(component, inputData = {}, options = {}) {
+        return this.withRetry(async () => {
+            const componentType = options.componentType || 'function';
+            const url = `${this.gatewayUrl}/v1/${componentType}s/${component}/run`;
+            const extra = {};
+            if (options.sessionId) {
+                extra['X-Session-ID'] = options.sessionId;
+            }
+            if (options.userId) {
+                extra['X-User-ID'] = options.userId;
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: this.buildHeaders(extra, options.tenant),
+                body: JSON.stringify(inputData),
+                signal: AbortSignal.timeout(this.timeout),
+            });
+            if (!response.ok) {
+                const errorData = (await response.json().catch(() => ({})));
+                const message = errorData.error || `Component '${component}' execution failed`;
+                throw createErrorFromResponse(response.status, message, errorData.runId || errorData.run_id, url);
+            }
+            const data = (await response.json());
+            return new RunResponse(data);
+        }, options.maxRetries);
+    }
+    /**
+     * Submit a component for async execution and return immediately.
+     */
+    async submit(component, inputData = {}, options = {}) {
+        const componentType = options.componentType || 'function';
+        const url = `${this.gatewayUrl}/v1/${componentType}s/${component}/submit`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.buildHeaders(undefined, options.tenant),
+            body: JSON.stringify(inputData),
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: Submission failed`);
+        }
+        const data = (await response.json());
+        return {
+            runId: data.run_id || data.runId || '',
+            status: data.status || 'enqueued',
+            traceId: data.trace_id,
+            component: data.component,
+            createdAt: data.created_at,
+        };
+    }
+    /**
+     * Get the current status of a run.
+     */
+    async getStatus(runId) {
+        const url = `${this.gatewayUrl}/v1/status/${runId}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: this.buildHeaders(),
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: Failed to get status`);
+        }
+        const data = (await response.json());
+        return new RunResponse(data);
+    }
+    /**
+     * Get the result of a completed run.
+     */
+    async getResult(runId) {
+        const url = `${this.gatewayUrl}/v1/result/${runId}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: this.buildHeaders(),
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (response.status === 404) {
+            const errorData = (await response.json().catch(() => ({})));
+            const errorMsg = errorData.error || 'Run not found or not complete';
+            const currentStatus = errorData.status || 'unknown';
+            throw new RunError(`${errorMsg} (status: ${currentStatus})`, runId);
+        }
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: Failed to get result`);
+        }
+        const data = (await response.json());
+        return new RunResponse(data);
+    }
+    /**
+     * Wait for a run to complete and return the result.
+     */
+    async waitForResult(runId, timeoutMs = 300000, pollIntervalMs = 1000) {
+        const startTime = Date.now();
+        while (true) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed >= timeoutMs) {
+                throw new RunError(`Timeout waiting for run to complete after ${timeoutMs}ms`, runId);
+            }
+            const status = await this.getStatus(runId);
+            if (['completed', 'failed', 'cancelled', 'timeout'].includes(status.status)) {
+                return await this.getResult(runId);
+            }
+            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+        }
+    }
+    /**
+     * Stream text chunks from a component using SSE.
+     * For typed events, use events() instead.
+     */
+    async *stream(component, inputData = {}, options = {}) {
+        for await (const event of this.events(component, inputData, options)) {
+            if (event.data.chunk !== undefined) {
+                yield event.data.chunk;
+            }
+        }
+    }
+    /**
+     * Stream typed events from a component using Server-Sent Events.
+     *
+     * @example
+     * ```typescript
+     * for await (const event of client.events('my-workflow', { data: '...' })) {
+     *   switch (event.eventType) {
+     *     case 'output.delta':
+     *       process.stdout.write(event.data.chunk);
+     *       break;
+     *     case 'run.completed':
+     *       console.log('Done:', event.data.output);
+     *       break;
+     *   }
+     * }
+     * ```
+     */
+    async *events(component, inputData = {}, options = {}) {
+        const componentType = options.componentType || 'function';
+        const url = `${this.gatewayUrl}/v1/${componentType}s/${component}/stream`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(inputData),
+            signal: AbortSignal.timeout(300000), // 5 minute timeout for streaming
+        });
+        if (!response.ok) {
+            throw new RunError(`HTTP ${response.status}: Streaming request failed`);
+        }
+        if (!response.body) {
+            throw new RunError('No response body for streaming');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentEventType = 'message';
+        let sequence = 0;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    // Skip comments
+                    if (trimmed.startsWith(':'))
+                        continue;
+                    // Empty line = end of event block
+                    if (!trimmed) {
+                        currentEventType = 'message';
+                        continue;
+                    }
+                    // Parse "event: <type>"
+                    if (trimmed.startsWith('event: ') || trimmed.startsWith('event:')) {
+                        currentEventType = trimmed.substring(trimmed.indexOf(':') + 1).trim();
+                        continue;
+                    }
+                    // Parse "data: <json>"
+                    if (trimmed.startsWith('data: ') || trimmed.startsWith('data:')) {
+                        const dataStr = trimmed.substring(trimmed.indexOf(':') + 1).trim();
+                        try {
+                            const data = JSON.parse(dataStr);
+                            // Check for stream-end signal
+                            if (data.done)
+                                return;
+                            // Check for error
+                            if (data.error && currentEventType === 'error') {
+                                throw new RunError(data.error, data.runId || data.run_id);
+                            }
+                            sequence++;
+                            yield {
+                                eventType: currentEventType,
+                                data,
+                                contentIndex: data.index ?? 0,
+                                sequence,
+                            };
+                        }
+                        catch (e) {
+                            if (e instanceof RunError)
+                                throw e;
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Get a proxy for calling methods on a durable entity
+     */
+    entity(entityType, key) {
+        return new EntityProxy(this, entityType, key);
+    }
+    /**
+     * Get all journal events for a completed run.
+     *
+     * @example
+     * ```typescript
+     * const events = await client.getEvents(runId);
+     * for (const event of events.events) {
+     *   console.log(event.eventType, event.data);
+     * }
+     * ```
+     */
+    async getEvents(runId) {
+        const url = `${this.gatewayUrl}/v1/runs/${runId}/events`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: this.buildHeaders(),
+        });
+        if (!response.ok) {
+            throw createErrorFromResponse(response.status, await response.text(), runId);
+        }
+        const data = await response.json();
+        const rawItems = Array.isArray(data?.items)
+            ? data.items
+            : Array.isArray(data?.events)
+                ? data.events
+                : Array.isArray(data)
+                    ? data
+                    : [];
+        const events = rawItems.map((e) => ({
+            eventType: e.event_type || e.eventType || '',
+            data: e.data || e.output_data || {},
+            timestamp: e.timestamp || e.created_at,
+            sequence: e.sequence ?? 0,
+            correlationId: e.correlation_id || e.correlationId,
+        }));
+        return { events, runId };
+    }
+    /**
+     * Get a proxy for invoking a workflow with fluent API.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.workflow('support_bot').chat('Help me', 'session-123');
+     * ```
+     */
+    workflow(workflowName) {
+        return new WorkflowProxy(this, workflowName);
+    }
+    /**
+     * Get a proxy for a session entity.
+     *
+     * @example
+     * ```typescript
+     * const session = client.session('Conversation', 'user-alice');
+     * const response = await session.chat('Hello!');
+     * ```
+     */
+    session(sessionType, key) {
+        return new SessionProxy(this, sessionType, key);
+    }
+    // ─── Batch operations ───────────────────────────────────────────────
+    /**
+     * Execute a component in batch with multiple inputs.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.batch('greet', [
+     *   { input: { name: 'Alice' } },
+     *   { input: { name: 'Bob' } },
+     * ], { maxConcurrency: 5 });
+     *
+     * if (result.isSuccess) {
+     *   console.log(result.outputs);
+     * }
+     * ```
+     */
+    async batch(component, items, options = {}) {
+        const componentType = options.componentType || 'function';
+        const url = `${this.gatewayUrl}/v1/${componentType}s/${component}/batch`;
+        // Normalize items: plain objects become { input: obj }
+        const normalizedItems = items.map((item, i) => {
+            if ('input' in item) {
+                return { ...item, index: item.index ?? i };
+            }
+            return { input: item, index: i };
+        });
+        const body = {
+            items: normalizedItems,
+            config: {
+                max_concurrency: options.maxConcurrency ?? 10,
+                continue_on_failure: options.continueOnFailure ?? true,
+                ...(options.batchTimeoutMs && { batch_timeout_ms: options.batchTimeoutMs }),
+                ...(options.defaultItemTimeoutMs && { default_item_timeout_ms: options.defaultItemTimeoutMs }),
+            },
+        };
+        if (options.metadata) {
+            body.metadata = options.metadata;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(options.batchTimeoutMs || 3600000),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json().catch(() => ({})));
+            throw createErrorFromResponse(response.status, errorData.error || `Batch execution failed for '${component}'`, undefined, url);
+        }
+        const data = await response.json();
+        return new BatchResult(data);
+    }
+    /**
+     * Get the status of a batch execution.
+     */
+    async getBatchStatus(batchId, includeResults = true) {
+        const url = `${this.gatewayUrl}/v1/batches/${batchId}?include_results=${includeResults}`;
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: this.buildHeaders(),
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (!response.ok) {
+            throw new RunError(`HTTP ${response.status}: Failed to get batch status`, batchId);
+        }
+        const data = await response.json();
+        return new BatchStatusResult(data);
+    }
+    /**
+     * Cancel a running batch execution.
+     */
+    async cancelBatch(batchId) {
+        const url = `${this.gatewayUrl}/v1/batches/${batchId}/cancel`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.buildHeaders(),
+            signal: AbortSignal.timeout(this.timeout),
+        });
+        if (!response.ok) {
+            throw new RunError(`HTTP ${response.status}: Failed to cancel batch`, batchId);
+        }
+        const data = (await response.json());
+        return {
+            batchId: data.batch_id || data.batchId || batchId,
+            status: data.status || 'cancelled',
+            cancelledItems: data.cancelled_items ?? data.cancelledItems ?? 0,
+            completedItems: data.completed_items ?? data.completedItems ?? 0,
+        };
+    }
+    // ─── Evaluation operations ──────────────────────────────────────────
+    /**
+     * Evaluate a component with scorers.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.eval('greet', { name: 'Alice' }, {
+     *   expected: 'Hello, Alice!',
+     *   scorers: ['exact_match', 'contains'],
+     * });
+     *
+     * if (result.passed) {
+     *   console.log('All scorers passed');
+     * }
+     * ```
+     */
+    async eval(component, inputData, options = {}) {
+        const componentType = options.componentType || 'function';
+        // Gateway exposes a single global eval route at POST /v1/eval; the
+        // component identity goes in the body, not the URL. See
+        // runtime/crates/gateway/src/server.rs and handlers/eval.rs
+        // (EvalRequest fields). Mirrors sdk-python/src/agnt5/client.py:709.
+        const url = `${this.gatewayUrl}/v1/eval`;
+        // Default to exact_match if expected is provided but no scorers
+        let scorers = options.scorers;
+        if (options.expected !== undefined && (!scorers || scorers.length === 0)) {
+            scorers = ['exact_match'];
+        }
+        const body = {
+            component,
+            component_type: componentType,
+        };
+        if (inputData !== undefined)
+            body.input = inputData;
+        if (options.expected !== undefined)
+            body.expected = options.expected;
+        if (scorers && scorers.length > 0)
+            body.scorers = normalizeScorerSpecs(scorers);
+        const extra = {};
+        if (options.sessionId)
+            extra['X-Session-ID'] = options.sessionId;
+        if (options.userId)
+            extra['X-User-ID'] = options.userId;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: this.buildHeaders(extra),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(options.timeout || this.timeout),
+        });
+        if (!response.ok) {
+            const errorData = (await response.json().catch(() => ({})));
+            throw createErrorFromResponse(response.status, errorData.error || `Evaluation failed for '${component}'`, errorData.run_id || errorData.runId, url);
+        }
+        const data = await response.json();
+        return new EvalResponse(data);
+    }
+    /**
+     * Evaluate a component in batch with multiple inputs and scorers.
+     *
+     * @example
+     * ```typescript
+     * const result = await client.batchEval('greet', [
+     *   { input: { name: 'Alice' }, expected: 'Hello, Alice!' },
+     *   { input: { name: 'Bob' }, expected: 'Hello, Bob!' },
+     * ], {
+     *   scorers: ['exact_match'],
+     *   maxConcurrency: 5,
+     * });
+     *
+     * console.log(`Pass rate: ${(result.passRate * 100).toFixed(1)}%`);
+     * ```
+     */
+    async batchEval(component, items, options = {}) {
+        const normalized = normalizeBatchEvalItems(items, options.expected);
+        const maxConcurrency = options.maxConcurrency ?? 10;
+        const startTime = Date.now();
+        // Run evaluations with concurrency limit
+        const results = [];
+        let running = 0;
+        let nextIdx = 0;
+        const runOne = async (item, idx) => {
+            try {
+                const evalResponse = await this.eval(component, item.input, {
+                    expected: item.expected,
+                    scorers: options.scorers,
+                    componentType: options.componentType,
+                    timeout: options.timeout,
+                });
+                results.push(BatchEvalItemResult.fromEvalResponse(evalResponse, idx, item.itemId));
+            }
+            catch (error) {
+                results.push(BatchEvalItemResult.fromException(error, idx, item.itemId));
+            }
+        };
+        // Simple semaphore-based concurrency
+        await new Promise((resolve) => {
+            const tryNext = () => {
+                while (running < maxConcurrency && nextIdx < normalized.length) {
+                    const item = normalized[nextIdx];
+                    const idx = nextIdx;
+                    nextIdx++;
+                    running++;
+                    runOne(item, idx).then(() => {
+                        running--;
+                        if (results.length === normalized.length) {
+                            resolve();
+                        }
+                        else {
+                            tryNext();
+                        }
+                    });
+                }
+                if (normalized.length === 0)
+                    resolve();
+            };
+            tryNext();
+        });
+        const totalDurationMs = Date.now() - startTime;
+        const hasErrors = results.some(r => r.isFailed);
+        const allErrors = results.every(r => r.isFailed);
+        const status = allErrors ? 'failed' : hasErrors ? 'partial_failure' : 'completed';
+        return new BatchEvalResult({
+            batchId: `batch_eval_${Date.now()}`,
+            status,
+            results,
+            durationMs: totalDurationMs,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// WorkflowProxy
+// ---------------------------------------------------------------------------
+export class WorkflowProxy {
+    constructor(client, workflowName) {
+        this.client = client;
+        this.workflowName = workflowName;
+    }
+    /** Execute the workflow synchronously */
+    async run(input, options) {
+        return this.client.run(this.workflowName, input, {
+            componentType: 'workflow',
+            sessionId: options?.sessionId,
+            userId: options?.userId,
+        });
+    }
+    /** Send a message to a chat-enabled workflow */
+    async chat(message, sessionId, options) {
+        const input = { message, ...(options?.extra || {}) };
+        return this.client.run(this.workflowName, input, {
+            componentType: 'workflow',
+            sessionId,
+            userId: options?.userId,
+        });
+    }
+    /** Submit the workflow for async execution */
+    async submit(input) {
+        return this.client.submit(this.workflowName, input, { componentType: 'workflow' });
+    }
+    /** Stream events from workflow execution */
+    async *events(input) {
+        yield* this.client.events(this.workflowName, input, {
+            componentType: 'workflow',
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// SessionProxy
+// ---------------------------------------------------------------------------
+export class SessionProxy extends EntityProxy {
+    /** Send a chat message to the session entity */
+    async chat(message, extra) {
+        return this.call('chat', { message, ...(extra || {}) });
+    }
+    /** Get conversation history from the session entity */
+    async getHistory() {
+        return this.call('get_history', {});
+    }
+}
+//# sourceMappingURL=client.js.map