taskforceai-sdk 1.2.0 → 1.3.0

package/LICENSE

@@ -0,0 +1,37 @@
+MIT License with Attribution Requirement for Large-Scale Commercial Use
+
+Copyright (c) 2025 Clay Warren
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+ADDITIONAL COMMERCIAL ATTRIBUTION REQUIREMENT:
+If you use this Software, in whole or in part, in any product, service, or
+application that serves more than 100,000 users, you must:
+
+1. Provide clear attribution to Clay Warren as the original creator
+2. Include a statement that your product uses the "TaskForceAI" framework
+3. This attribution must be visible in one of the following locations:
+   - Product documentation
+   - About page/section
+   - Credits section
+   - Help/support documentation
+   - Or equivalent user-accessible location
+
+Example attribution: "Powered by TaskForceAI by Clay Warren"
+or "Uses TaskForceAI multi-agent system created by Clay Warren"
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -22,22 +22,38 @@ const client = new TaskForceAI({
 // Submit a task (using default free model)
 const taskId = await client.submitTask('Test prompt');
 
-// Or submit with your own OpenRouter key for premium models
+// Or submit with your own Vercel AI Gateway key for premium models
 const taskId2 = await client.submitTask('Complex analysis', {
-  openRouterKey: 'your-openrouter-key-here',
+  vercelAiKey: 'your-vercel-ai-key-here',
 });
 
 // Wait for completion
 const result = await client.waitForCompletion(taskId);
-console.log(result.result);
+// handle result.result here
 
 // Or stream status updates
 const stream = client.streamTaskStatus(taskId);
 for await (const status of stream) {
-  console.log(status.status, status.result);
+  // handle incremental status updates
 }
 ```
 
+## Mock Mode
+
+Build and test your integration without an API key using mock mode:
+
+```typescript
+import { TaskForceAI } from 'taskforceai-sdk';
+
+// No API key required in mock mode
+const client = new TaskForceAI({ mockMode: true });
+
+const result = await client.runTask('Test your integration');
+console.log(result.result); // "This is a mock response. Configure your API key to get real results."
+```
+
+Mock mode simulates the full task lifecycle locally—no network requests are made. Tasks go through "processing" then "completed" states, making it easy to build UIs and test error handling before launch.
+
 ## API Reference
 
 ### TaskForceAI
@@ -52,10 +68,11 @@ constructor(options: TaskForceAIOptions)
 
 **Options:**
 
-- `apiKey` (required): Your API key
+- `apiKey` (required unless `mockMode` is true): Your API key
 - `baseUrl` (optional): API base URL (default: https://taskforceai.chat/api/developer)
 - `timeout` (optional): Request timeout in milliseconds (default: 30000)
 - `responseHook` (optional): Callback invoked with every raw `fetch` response
+- `mockMode` (optional): Enable mock mode for development without an API key (default: false)
 
 #### Methods
 
@@ -75,7 +92,7 @@ async submitTask(
 - `prompt`: The user's input prompt
 - `options.silent`: Suppress logging (default: false)
 - `options.mock`: Use mock responses for testing (default: false)
-- `options.openRouterKey`: Supply your own OpenRouter API key to pick premium models
+- `options.vercelAiKey`: Supply your own Vercel AI Gateway API key to pick premium models
 - `options.*`: Any additional TaskForceAI orchestration flags are forwarded untouched
 
 **Returns:** Task ID string
@@ -155,7 +172,7 @@ try {
   const result = await client.runTask('Your prompt');
 } catch (error) {
   if (error instanceof TaskForceAIError) {
-    console.error(`API Error: ${error.message} (Status: ${error.statusCode})`);
+    // handle API error, inspect error.statusCode and error.details
   }
 }
 ```

package/dist/index.d.ts

@@ -1,98 +1,25 @@
-/**
- * TaskForceAI SDK version
- */
-export declare const VERSION = "1.1.0";
-export interface TaskForceAIOptions {
-    apiKey: string;
-    baseUrl?: string;
-    timeout?: number;
-    responseHook?: TaskResponseHook;
-}
-export type TaskSubmissionOptions = {
-    [key: string]: unknown;
-    silent?: boolean;
-    mock?: boolean;
-    openRouterKey?: string;
-};
-export interface TaskStatus {
-    taskId: string;
-    status: 'processing' | 'completed' | 'failed';
-    result?: string;
-    error?: string;
-    warnings?: string[];
-    metadata?: Record<string, unknown>;
-}
-export interface TaskResult extends TaskStatus {
-    status: 'completed';
-    result: string;
-}
-export type TaskStatusCallback = (status: TaskStatus) => void;
-export type TaskResponseHook = (response: Response) => void;
-export declare class TaskStatusStream implements AsyncIterable<TaskStatus> {
-    private readonly client;
-    readonly taskId: string;
-    private readonly pollInterval;
-    private readonly maxAttempts;
-    private readonly onStatus?;
-    private cancelled;
-    constructor(client: TaskForceAI, taskId: string, pollInterval: number, maxAttempts: number, onStatus?: TaskStatusCallback | undefined);
-    cancel(): void;
-    [Symbol.asyncIterator](): AsyncIterator<TaskStatus>;
-}
-export declare class TaskForceAIError extends Error {
-    statusCode?: number | undefined;
-    constructor(message: string, statusCode?: number | undefined);
-}
+/// <reference types="node" />
+import { TaskForceAIError, transportDefaults as def } from './transport';
+import type { TaskForceAIOptions, TaskResult, TaskStatus, TaskStatusCallback, TaskStatusStream, TaskSubmissionOptions } from './types';
+import { VERSION } from './types';
 export declare class TaskForceAI {
-    private apiKey;
-    private baseUrl;
-    private timeout;
-    private responseHook?;
-    constructor(options: TaskForceAIOptions);
-    private makeRequest;
-    /**
-     * Submit a task for multi-agent orchestration.
-     *
-     * @param prompt - The user's input prompt
-     * @param options - Optional settings for the task
-     * @returns Promise<string> - The task ID
-     */
-    submitTask(prompt: string, options?: TaskSubmissionOptions): Promise<string>;
-    /**
-     * Get the status of a submitted task.
-     *
-     * @param taskId - The task ID returned from submitTask
-     * @returns Promise<TaskStatus> - The current task status
-     */
-    getTaskStatus(taskId: string): Promise<TaskStatus>;
-    /**
-     * Get the final result of a completed task.
-     *
-     * @param taskId - The task ID returned from submitTask
-     * @returns Promise<TaskResult> - The task result
-     */
-    getTaskResult(taskId: string): Promise<TaskResult>;
-    /**
-     * Wait for a task to complete and return the result.
-     * This method polls the status until the task is completed or failed.
-     *
-     * @param taskId - The task ID returned from submitTask
-     * @param pollInterval - Interval between status checks in milliseconds (default: 2000)
-     * @param maxAttempts - Maximum number of polling attempts (default: 150)
-     * @returns Promise<TaskResult> - The final task result
-     */
-    waitForCompletion(taskId: string, pollInterval?: number, maxAttempts?: number, onStatus?: TaskStatusCallback): Promise<TaskResult>;
-    /**
-     * Submit a task and wait for completion in one call.
-     *
-     * @param prompt - The user's input prompt
-     * @param options - Optional settings for the task
-     * @param pollInterval - Interval between status checks in milliseconds (default: 2000)
-     * @param maxAttempts - Maximum number of polling attempts (default: 150)
-     * @returns Promise<TaskResult> - The final task result
-     */
-    runTask(prompt: string, options?: TaskSubmissionOptions, pollInterval?: number, maxAttempts?: number, onStatus?: TaskStatusCallback): Promise<TaskResult>;
-    streamTaskStatus(taskId: string, pollInterval?: number, maxAttempts?: number, onStatus?: TaskStatusCallback): TaskStatusStream;
-    runTaskStream(prompt: string, options?: TaskSubmissionOptions, pollInterval?: number, maxAttempts?: number, onStatus?: TaskStatusCallback): Promise<TaskStatusStream>;
+    private ak;
+    private url;
+    private t;
+    private rh?;
+    private mm;
+    private mcc;
+    constructor(o: TaskForceAIOptions);
+    private mockResponse;
+    private req;
+    submitTask(p: string, o?: TaskSubmissionOptions): Promise<string>;
+    getTaskStatus(id: any): Promise<TaskStatus>;
+    getTaskResult(id: any): Promise<TaskResult>;
+    private poll;
+    waitForCompletion(id: string, ms?: 2000, max?: 150, on?: TaskStatusCallback, sig?: AbortSignal): Promise<TaskResult>;
+    runTask(p: string, o?: TaskSubmissionOptions, ms?: 2000, max?: 150, on?: TaskStatusCallback): Promise<TaskResult>;
+    streamTaskStatus(id: any, ms?: 2000, max?: 150, on?: TaskStatusCallback, sig?: AbortSignal): TaskStatusStream;
+    runTaskStream(p: string, o?: TaskSubmissionOptions, ms?: 2000, max?: 150, on?: TaskStatusCallback, sig?: AbortSignal): Promise<TaskStatusStream>;
 }
+export { TaskForceAIError, TaskStatus, TaskResult, TaskSubmissionOptions, TaskStatusCallback, TaskStatusStream, TaskForceAIOptions, VERSION, def as transportDefaults, };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,IAAI,GAAG,EAAe,MAAM,aAAa,CAAC;AACtF,OAAO,KAAK,EACV,kBAAkB,EAClB,UAAU,EACV,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AASlC,qBAAa,WAAW;IACtB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,EAAE,CAAC,CAAwB;IACnC,OAAO,CAAC,EAAE,CAAU;IACpB,OAAO,CAAC,GAAG,CAAkC;gBAEjC,CAAC,EAAE,kBAAkB;IAWjC,OAAO,CAAC,YAAY;IAsBpB,OAAO,CAAC,GAAG,CAWT;IAEI,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,qBAA0B,GAAG,OAAO,CAAC,MAAM,CAAC;IAWrE,aAAa,CAAC,EAAE,EAAE,GAAG;IAKrB,aAAa,CAAC,EAAE,EAAE,GAAG;YAMZ,IAAI;IAoBb,iBAAiB,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,OAAqB,EACvB,GAAG,MAAsB,EACzB,EAAE,CAAC,EAAE,kBAAkB,EACvB,GAAG,CAAC,EAAE,WAAW,GAChB,OAAO,CAAC,UAAU,CAAC;IAQhB,OAAO,CACX,CAAC,EAAE,MAAM,EACT,CAAC,GAAE,qBAA0B,EAC7B,EAAE,OAAqB,EACvB,GAAG,MAAsB,EACzB,EAAE,CAAC,EAAE,kBAAkB;IAKzB,gBAAgB,CACd,EAAE,EAAE,GAAG,EACP,EAAE,OAAqB,EACvB,GAAG,MAAsB,EACzB,EAAE,CAAC,EAAE,kBAAkB,EACvB,GAAG,CAAC,EAAE,WAAW,GAChB,gBAAgB;IAgBb,aAAa,CACjB,CAAC,EAAE,MAAM,EACT,CAAC,GAAE,qBAA0B,EAC7B,EAAE,OAAqB,EACvB,GAAG,MAAsB,EACzB,EAAE,CAAC,EAAE,kBAAkB,EACvB,GAAG,CAAC,EAAE,WAAW;CAIpB;AAED,OAAO,EACL,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,OAAO,EACP,GAAG,IAAI,iBAAiB,GACzB,CAAC"}

package/dist/index.js

@@ -1,207 +1,118 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskForceAI = exports.TaskForceAIError = exports.TaskStatusStream = exports.VERSION = void 0;
-/**
- * TaskForceAI SDK version
- */
-exports.VERSION = '1.1.0';
-class TaskStatusStream {
-    constructor(client, taskId, pollInterval, maxAttempts, onStatus) {
-        this.client = client;
-        this.taskId = taskId;
-        this.pollInterval = pollInterval;
-        this.maxAttempts = maxAttempts;
-        this.onStatus = onStatus;
-        this.cancelled = false;
-    }
-    cancel() {
-        this.cancelled = true;
-    }
-    async *[Symbol.asyncIterator]() {
-        for (let attempt = 0; attempt < this.maxAttempts; attempt += 1) {
-            if (this.cancelled) {
-                throw new TaskForceAIError('Task stream cancelled');
-            }
-            const status = await this.client.getTaskStatus(this.taskId);
-            this.onStatus?.(status);
-            yield status;
-            if (status.status === 'completed' || status.status === 'failed') {
-                return;
-            }
-            await new Promise((resolve) => setTimeout(resolve, this.pollInterval));
-        }
-        throw new TaskForceAIError('Task did not complete within the expected time');
-    }
-}
-exports.TaskStatusStream = TaskStatusStream;
-class TaskForceAIError extends Error {
-    constructor(message, statusCode) {
-        super(message);
-        this.statusCode = statusCode;
-        this.name = 'TaskForceAIError';
-    }
-}
-exports.TaskForceAIError = TaskForceAIError;
+exports.transportDefaults = exports.VERSION = exports.TaskForceAIError = exports.TaskForceAI = void 0;
+const transport_1 = require("./transport");
+Object.defineProperty(exports, "TaskForceAIError", { enumerable: true, get: function () { return transport_1.TaskForceAIError; } });
+Object.defineProperty(exports, "transportDefaults", { enumerable: true, get: function () { return transport_1.transportDefaults; } });
+const types_1 = require("./types");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return types_1.VERSION; } });
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+});
+const MOCK_RESULT = 'This is a mock response. Configure your API key to get real results.';
 class TaskForceAI {
-    constructor(options) {
-        this.apiKey = options.apiKey;
-        this.baseUrl = options.baseUrl || 'https://taskforceai.chat/api/developer';
-        this.timeout = options.timeout || 30000; // 30 seconds
-        this.responseHook = options.responseHook;
-    }
-    async makeRequest(endpoint, options = {}) {
-        // @ts-ignore - TypeScript has issues with generic JSON parsing
-        const url = `${this.baseUrl}${endpoint}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const response = await fetch(url, {
-                ...options,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': this.apiKey,
-                    ...options.headers,
-                },
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (this.responseHook) {
-                const cloned = response.clone();
-                this.responseHook(cloned);
+    constructor(o) {
+        this.mcc = new Map();
+        this.req = (e, i = {}, r = false) => {
+            if (this.mm) {
+                return Promise.resolve(this.mockResponse(e, i.method || 'GET'));
             }
-            if (!response.ok) {
-                let errorMessage = `HTTP ${response.status}`;
-                try {
-                    const errorText = await response.text();
-                    try {
-                        const errorData = JSON.parse(errorText);
-                        if (errorData && typeof errorData === 'object' && 'error' in errorData) {
-                            errorMessage = errorData.error;
-                        }
-                    }
-                    catch {
-                        // Ignore JSON parse errors
-                    }
-                }
-                catch {
-                    // Ignore JSON parse errors, use default message
-                }
-                throw new TaskForceAIError(errorMessage, response.status);
-            }
-            const data = await response.json();
-            return data;
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof TaskForceAIError) {
-                throw error;
-            }
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new TaskForceAIError('Request timeout');
-            }
-            throw new TaskForceAIError(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return (0, transport_1.makeRequest)(e, i, { apiKey: this.ak, baseUrl: this.url, timeout: this.t, responseHook: this.rh }, r, transport_1.transportDefaults.maxRetries);
+        };
+        this.mm = o.mockMode ?? false;
+        if (!this.mm && !o.apiKey) {
+            throw new transport_1.TaskForceAIError('API key is required when not in mock mode');
         }
+        this.ak = o.apiKey || '';
+        this.url = o.baseUrl || 'https://taskforceai.chat/api/developer';
+        this.t = o.timeout || transport_1.transportDefaults.timeout;
+        this.rh = o.responseHook;
     }
-    /**
-     * Submit a task for multi-agent orchestration.
-     *
-     * @param prompt - The user's input prompt
-     * @param options - Optional settings for the task
-     * @returns Promise<string> - The task ID
-     */
-    async submitTask(prompt, options = {}) {
-        if (!prompt || typeof prompt !== 'string') {
-            throw new TaskForceAIError('Prompt must be a non-empty string');
+    mockResponse(e, method) {
+        if (method === 'POST' && e === '/run') {
+            const taskId = `mock-${Math.random().toString(36).slice(2, 10)}`;
+            this.mcc.set(taskId, 0);
+            return { taskId, status: 'processing' };
         }
-        const { openRouterKey, silent, mock, ...optionFlags } = options;
-        const payload = { prompt };
-        const normalizedOptions = {
-            silent: typeof silent === 'boolean' ? silent : false,
-            mock: typeof mock === 'boolean' ? mock : false,
-            ...optionFlags,
-        };
-        if (Object.keys(normalizedOptions).length > 0) {
-            payload.options = normalizedOptions;
+        if (e.startsWith('/status/')) {
+            const taskId = e.split('/').pop();
+            const count = this.mcc.get(taskId) || 0;
+            this.mcc.set(taskId, count + 1);
+            if (count < 1) {
+                return { taskId, status: 'processing', message: 'Mock task processing...' };
+            }
+            return { taskId, status: 'completed', result: MOCK_RESULT };
         }
-        if (openRouterKey) {
-            payload.openRouterKey = openRouterKey;
+        if (e.startsWith('/results/')) {
+            const taskId = e.split('/').pop();
+            return { taskId, status: 'completed', result: MOCK_RESULT };
         }
-        const response = await this.makeRequest('/run', {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        });
-        return response.taskId;
+        return { status: 'ok' };
     }
-    /**
-     * Get the status of a submitted task.
-     *
-     * @param taskId - The task ID returned from submitTask
-     * @returns Promise<TaskStatus> - The current task status
-     */
-    async getTaskStatus(taskId) {
-        if (!taskId || typeof taskId !== 'string') {
-            throw new TaskForceAIError('Task ID must be a non-empty string');
-        }
-        return this.makeRequest(`/status/${taskId}`);
+    async submitTask(p, o = {}) {
+        if (typeof p !== 'string' || !p.trim())
+            throw new transport_1.TaskForceAIError('Prompt must be a non-empty string');
+        const { vercelAiKey: v, silent: s = false, mock: m = false, ...rest } = o;
+        const body = { prompt: p, options: { silent: s, mock: m, ...rest } };
+        if (v)
+            body.vercelAiKey = v;
+        return (await this.req('/run', { method: 'POST', body: JSON.stringify(body) })).taskId;
+    }
+    async getTaskStatus(id) {
+        if (!id || typeof id !== 'string')
+            throw new transport_1.TaskForceAIError('Task ID must be a non-empty string');
+        return this.req(`/status/${id}`, {}, true);
     }
-    /**
-     * Get the final result of a completed task.
-     *
-     * @param taskId - The task ID returned from submitTask
-     * @returns Promise<TaskResult> - The task result
-     */
-    async getTaskResult(taskId) {
-        if (!taskId || typeof taskId !== 'string') {
-            throw new TaskForceAIError('Task ID must be a non-empty string');
+    async getTaskResult(id) {
+        if (!id || typeof id !== 'string')
+            throw new transport_1.TaskForceAIError('Task ID must be a non-empty string');
+        return this.req(`/results/${id}`);
+    }
+    async *poll(id, ms, max, on, sig) {
+        for (let i = 0; i < max; i++) {
+            if (sig?.aborted)
+                throw new transport_1.TaskForceAIError('Task polling cancelled');
+            // eslint-disable-next-line no-await-in-loop
+            const s = await this.getTaskStatus(id);
+            on?.(s);
+            yield s;
+            if (['completed', 'failed'].includes(s.status))
+                return;
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(ms);
         }
-        return this.makeRequest(`/results/${taskId}`);
+        throw new transport_1.TaskForceAIError('Task did not complete within the expected time');
     }
-    /**
-     * Wait for a task to complete and return the result.
-     * This method polls the status until the task is completed or failed.
-     *
-     * @param taskId - The task ID returned from submitTask
-     * @param pollInterval - Interval between status checks in milliseconds (default: 2000)
-     * @param maxAttempts - Maximum number of polling attempts (default: 150)
-     * @returns Promise<TaskResult> - The final task result
-     */
-    async waitForCompletion(taskId, pollInterval = 2000, maxAttempts = 150, onStatus) {
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            const status = await this.getTaskStatus(taskId);
-            onStatus?.(status);
-            if (status.status === 'completed' && status.result !== undefined) {
-                return status;
-            }
-            if (status.status === 'failed') {
-                throw new TaskForceAIError(status.error || 'Task failed');
-            }
-            // Wait before next poll
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    async waitForCompletion(id, ms = transport_1.transportDefaults.pollIntervalMs, max = transport_1.transportDefaults.maxPollAttempts, on, sig) {
+        for await (const s of this.poll(id, ms, max, on, sig)) {
+            if (s.status === 'completed' && s.result)
+                return s;
+            if (s.status === 'failed')
+                throw new transport_1.TaskForceAIError(s.error || 'Task failed');
         }
-        throw new TaskForceAIError('Task did not complete within the expected time');
+        throw new transport_1.TaskForceAIError('Task did not complete within the expected time');
     }
-    /**
-     * Submit a task and wait for completion in one call.
-     *
-     * @param prompt - The user's input prompt
-     * @param options - Optional settings for the task
-     * @param pollInterval - Interval between status checks in milliseconds (default: 2000)
-     * @param maxAttempts - Maximum number of polling attempts (default: 150)
-     * @returns Promise<TaskResult> - The final task result
-     */
-    async runTask(prompt, options = {}, pollInterval = 2000, maxAttempts = 150, onStatus) {
-        const taskId = await this.submitTask(prompt, options);
-        return this.waitForCompletion(taskId, pollInterval, maxAttempts, onStatus);
+    async runTask(p, o = {}, ms = transport_1.transportDefaults.pollIntervalMs, max = transport_1.transportDefaults.maxPollAttempts, on) {
+        return this.waitForCompletion(await this.submitTask(p, o), ms, max, on);
     }
-    streamTaskStatus(taskId, pollInterval = 2000, maxAttempts = 150, onStatus) {
-        if (!taskId || typeof taskId !== 'string') {
-            throw new TaskForceAIError('Task ID must be a non-empty string');
-        }
-        return new TaskStatusStream(this, taskId, pollInterval, maxAttempts, onStatus);
+    streamTaskStatus(id, ms = transport_1.transportDefaults.pollIntervalMs, max = transport_1.transportDefaults.maxPollAttempts, on, sig) {
+        if (!id || typeof id !== 'string')
+            throw new transport_1.TaskForceAIError('Task ID must be a non-empty string');
+        let cancel = false;
+        return {
+            taskId: id,
+            cancel: () => (cancel = true),
+            [Symbol.asyncIterator]: async function* () {
+                for await (const s of this.poll(id, ms, max, on, sig)) {
+                    if (cancel)
+                        throw new transport_1.TaskForceAIError('Task stream cancelled');
+                    yield s;
+                }
+            }.bind(this),
+        };
     }
-    async runTaskStream(prompt, options = {}, pollInterval = 2000, maxAttempts = 150, onStatus) {
-        const taskId = await this.submitTask(prompt, options);
-        return new TaskStatusStream(this, taskId, pollInterval, maxAttempts, onStatus);
+    async runTaskStream(p, o = {}, ms = transport_1.transportDefaults.pollIntervalMs, max = transport_1.transportDefaults.maxPollAttempts, on, sig) {
+        return this.streamTaskStatus(await this.submitTask(p, o), ms, max, on, sig);
     }
 }
 exports.TaskForceAI = TaskForceAI;

package/dist/transport.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+export declare class TaskForceAIError extends Error {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined);
+}
+export interface TransportConfig {
+    apiKey: string;
+    baseUrl: string;
+    timeout: number;
+    responseHook?: (response: Response) => void;
+}
+export declare const makeRequest: <T>(endpoint: string, options: RequestInit, { apiKey, baseUrl, timeout, responseHook }: TransportConfig, retryable?: boolean, maxRetries?: number) => Promise<T>;
+export declare const transportDefaults: {
+    readonly timeout: 30000;
+    readonly maxRetries: 3;
+    readonly backoffMs: 500;
+    readonly pollIntervalMs: 2000;
+    readonly maxPollAttempts: 150;
+};
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":";AAsCA,qBAAa,gBAAiB,SAAQ,KAAK;IAGhC,UAAU,CAAC;gBADlB,OAAO,EAAE,MAAM,EACR,UAAU,CAAC,oBAAQ;CAK7B;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;CAC7C;AAED,eAAO,MAAM,WAAW,gBACZ,MAAM,WACP,WAAW,8CACwB,eAAe,yDA4D5D,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;CAMpB,CAAC"}

package/dist/transport.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transportDefaults = exports.makeRequest = exports.TaskForceAIError = void 0;
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_BACKOFF_MS = 500;
+const DEFAULT_MAX_RETRIES = 3;
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+});
+const buildSignal = (timeoutMs, externalSignal) => {
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    return externalSignal ? AbortSignal.any([timeoutSignal, externalSignal]) : timeoutSignal;
+};
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const parseErrorMessage = async (response) => {
+    try {
+        const errorText = await response.text();
+        try {
+            const parsed = JSON.parse(errorText);
+            if (isRecord(parsed)) {
+                if (typeof parsed['error'] === 'string') {
+                    return parsed['error'];
+                }
+                return `HTTP ${response.status}`;
+            }
+        }
+        catch {
+            // Not JSON, fall back to text
+        }
+        if (errorText.trim().length > 0)
+            return errorText;
+    }
+    catch {
+        /* ignore body errors */
+    }
+    return `HTTP ${response.status}`;
+};
+class TaskForceAIError extends Error {
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = 'TaskForceAIError';
+    }
+}
+exports.TaskForceAIError = TaskForceAIError;
+const makeRequest = async (endpoint, options, { apiKey, baseUrl, timeout, responseHook }, retryable = false, maxRetries = DEFAULT_MAX_RETRIES) => {
+    const url = `${baseUrl}${endpoint}`;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+        try {
+            // eslint-disable-next-line no-await-in-loop
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    ...options.headers,
+                },
+                signal: buildSignal(timeout, options.signal),
+            });
+            if (responseHook) {
+                try {
+                    responseHook(response.clone());
+                }
+                catch {
+                    /* ignore hook errors */
+                }
+            }
+            if (!response.ok) {
+                // eslint-disable-next-line no-await-in-loop
+                const errorMessage = await parseErrorMessage(response);
+                const shouldRetry = retryable && response.status >= 500 && response.status < 600 && attempt < maxRetries;
+                if (shouldRetry) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await sleep(DEFAULT_BACKOFF_MS * (attempt + 1));
+                    continue;
+                }
+                throw new TaskForceAIError(errorMessage, response.status);
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const data = (await response.json());
+            return data;
+        }
+        catch (error) {
+            if (error instanceof TaskForceAIError)
+                throw error;
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new TaskForceAIError('Request timeout');
+            }
+            if (retryable && attempt < maxRetries) {
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(DEFAULT_BACKOFF_MS * (attempt + 1));
+                continue;
+            }
+            throw new TaskForceAIError(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    throw new TaskForceAIError('Request failed after maximum retries');
+};
+exports.makeRequest = makeRequest;
+exports.transportDefaults = {
+    timeout: DEFAULT_TIMEOUT_MS,
+    maxRetries: DEFAULT_MAX_RETRIES,
+    backoffMs: DEFAULT_BACKOFF_MS,
+    pollIntervalMs: 2000,
+    maxPollAttempts: 150,
+};

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+export declare const VERSION = "1.2.1";
+export interface TaskForceAIOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+    responseHook?: TaskResponseHook;
+    mockMode?: boolean;
+}
+export type TaskSubmissionOptions = {
+    [key: string]: unknown;
+    silent?: boolean;
+    mock?: boolean;
+    vercelAiKey?: string;
+};
+export interface TaskStatus {
+    taskId: string;
+    status: 'processing' | 'completed' | 'failed';
+    result?: string;
+    error?: string;
+    warnings?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface TaskResult extends TaskStatus {
+    status: 'completed';
+    result: string;
+}
+export type TaskStatusCallback = (status: TaskStatus) => void;
+export type TaskResponseHook = (response: Response) => void;
+export interface TaskStatusStream extends AsyncIterable<TaskStatus> {
+    taskId: string;
+    cancel(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA,eAAO,MAAM,OAAO,UAAU,CAAC;AAE/B,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,UAAW,SAAQ,UAAU;IAC5C,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC;AAE5D,MAAM,WAAW,gBAAiB,SAAQ,aAAa,CAAC,UAAU,CAAC;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,IAAI,IAAI,CAAC;CAChB"}

package/dist/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '1.2.1';

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "taskforceai-sdk",
-  "version": "1.2.0",
-  "description": "Official SDK for TaskForceAI multi-agent orchestration API",
+  "version": "1.3.0",
+  "description": "TypeScript SDK for TaskForceAI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "scripts": {
     "build": "tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "bun test --preload ../../tests/bun-setup.ts",
+    "test:watch": "bun test --watch --preload ../../tests/bun-setup.ts",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -21,19 +27,28 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ClayWarren/grok4fastheavy"
+    "url": "git+https://github.com/ClayWarren/taskforceai-sdk-typescript.git"
   },
   "bugs": {
-    "url": "https://github.com/ClayWarren/grok4fastheavy/issues"
+    "url": "https://github.com/ClayWarren/taskforceai-sdk-typescript/issues"
   },
   "homepage": "https://taskforceai.chat",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.12.0"
   },
+  "dependencies": {},
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.7",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.7"
+    "@taskforce/shared": "workspace:*",
+    "@taskforceai/toolchain": "workspace:*",
+    "zod": "catalog:"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
   },
   "files": [
     "dist/**/*",

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const index_1 = require("./index");
-const globalWithFetch = globalThis;
-const originalFetch = globalWithFetch.fetch;
-function createMockResponse(data) {
-    return {
-        ok: true,
-        status: 200,
-        json: async () => data,
-    };
-}
-(0, vitest_1.afterEach)(() => {
-    vitest_1.vi.restoreAllMocks();
-    vitest_1.vi.useRealTimers();
-    if (originalFetch !== undefined) {
-        globalWithFetch.fetch = originalFetch;
-    }
-    else {
-        delete globalWithFetch.fetch;
-    }
-});
-(0, vitest_1.describe)('TaskForceAI.makeRequest and helpers', () => {
-    (0, vitest_1.it)('includes openRouterKey at the top level of the payload', async () => {
-        const fetchMock = vitest_1.vi
-            .fn()
-            .mockResolvedValue(createMockResponse({ taskId: 'task_123', status: 'processing', message: 'ok' }));
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({
-            apiKey: 'test-api-key',
-            baseUrl: 'https://example.com/api/developer',
-        });
-        const taskId = await client.submitTask('Analyze data', {
-            openRouterKey: 'or-key',
-            mock: true,
-        });
-        (0, vitest_1.expect)(taskId).toBe('task_123');
-        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
-        const [url, options] = fetchMock.mock.calls[0];
-        (0, vitest_1.expect)(url).toBe('https://example.com/api/developer/run');
-        const parsedBody = JSON.parse(options?.body || '{}');
-        (0, vitest_1.expect)(parsedBody).toEqual({
-            prompt: 'Analyze data',
-            options: { mock: true },
-            openRouterKey: 'or-key',
-        });
-    });
-    (0, vitest_1.it)('omits options when only openRouterKey is provided', async () => {
-        const fetchMock = vitest_1.vi
-            .fn()
-            .mockResolvedValue(createMockResponse({ taskId: 'task_456', status: 'processing', message: 'ok' }));
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({
-            apiKey: 'test-api-key',
-        });
-        await client.submitTask('Summarize report', {
-            openRouterKey: 'or-key',
-        });
-        (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
-        const [, options] = fetchMock.mock.calls[0];
-        const parsedBody = JSON.parse(options?.body || '{}');
-        (0, vitest_1.expect)(parsedBody).toEqual({
-            prompt: 'Summarize report',
-            openRouterKey: 'or-key',
-        });
-    });
-    (0, vitest_1.it)('throws a TaskForceAIError when prompt is invalid', async () => {
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        await (0, vitest_1.expect)(client.submitTask('')).rejects.toThrow('Prompt must be a non-empty string');
-    });
-    (0, vitest_1.it)('extracts JSON error messages from failed responses', async () => {
-        const fetchMock = vitest_1.vi.fn().mockResolvedValue({
-            ok: false,
-            status: 404,
-            text: async () => JSON.stringify({ error: 'Not found' }),
-            json: async () => ({}),
-        });
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({ apiKey: 'key', baseUrl: 'https://example.com/api/developer' });
-        await (0, vitest_1.expect)(client.getTaskStatus('missing')).rejects.toThrowError(new index_1.TaskForceAIError('Not found', 404));
-    });
-    (0, vitest_1.it)('falls back to status code when error payload lacks error field', async () => {
-        const fetchMock = vitest_1.vi.fn().mockResolvedValue({
-            ok: false,
-            status: 500,
-            text: async () => JSON.stringify({ message: 'oops' }),
-            json: async () => ({}),
-        });
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({ apiKey: 'key', baseUrl: 'https://example.com/api/developer' });
-        await (0, vitest_1.expect)(client.getTaskStatus('task')).rejects.toMatchObject({
-            message: 'HTTP 500',
-            statusCode: 500,
-        });
-    });
-    (0, vitest_1.it)('wraps network errors into TaskForceAIError', async () => {
-        const fetchMock = vitest_1.vi.fn().mockRejectedValue(new Error('unreachable'));
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        await (0, vitest_1.expect)(client.submitTask('prompt')).rejects.toThrow('Network error: unreachable');
-    });
-    (0, vitest_1.it)('treats non-Error rejections as unknown network errors', async () => {
-        const fetchMock = vitest_1.vi.fn().mockRejectedValue('fail');
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        await (0, vitest_1.expect)(client.submitTask('prompt')).rejects.toThrow('Network error: Unknown error');
-    });
-    (0, vitest_1.it)('converts AbortError into timeout error', async () => {
-        vitest_1.vi.useFakeTimers();
-        const fetchMock = vitest_1.vi.fn((_, init) => {
-            const signal = init?.signal;
-            return new Promise((_, reject) => {
-                signal?.addEventListener('abort', () => {
-                    const error = new Error('Aborted');
-                    error.name = 'AbortError';
-                    reject(error);
-                });
-            });
-        });
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({ apiKey: 'key', timeout: 100 });
-        const promise = client.getTaskStatus('slow-task');
-        const expectation = (0, vitest_1.expect)(promise).rejects.toThrow('Request timeout');
-        await vitest_1.vi.advanceTimersByTimeAsync(100);
-        await expectation;
-    });
-});
-(0, vitest_1.describe)('TaskForceAI task helpers', () => {
-    (0, vitest_1.it)('validates task identifiers for status and result lookups', async () => {
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        await (0, vitest_1.expect)(client.getTaskStatus('')).rejects.toThrow('Task ID must be a non-empty string');
-        await (0, vitest_1.expect)(client.getTaskResult('')).rejects.toThrow('Task ID must be a non-empty string');
-    });
-    (0, vitest_1.it)('fetches task status and result through makeRequest', async () => {
-        const fetchMock = vitest_1.vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ taskId: 'task', status: 'completed', result: 'done' }),
-        });
-        globalWithFetch.fetch = fetchMock;
-        const client = new index_1.TaskForceAI({ apiKey: 'key', baseUrl: 'https://example.com/api/developer' });
-        const status = await client.getTaskStatus('task');
-        (0, vitest_1.expect)(status.status).toBe('completed');
-        fetchMock.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: async () => ({ taskId: 'task', result: 'done' }),
-        });
-        const result = await client.getTaskResult('task');
-        (0, vitest_1.expect)(result.result).toBe('done');
-    });
-    (0, vitest_1.it)('waits for completion successfully', async () => {
-        vitest_1.vi.useFakeTimers();
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        const statuses = [
-            { taskId: 'task', status: 'processing' },
-            { taskId: 'task', status: 'completed', result: 'done' },
-        ];
-        const statusSpy = vitest_1.vi
-            .spyOn(client, 'getTaskStatus')
-            .mockImplementation(async () => statuses.shift());
-        const promise = client.waitForCompletion('task', 50, 5);
-        await vitest_1.vi.advanceTimersByTimeAsync(50);
-        const finalResult = await promise;
-        (0, vitest_1.expect)(finalResult).toEqual({ taskId: 'task', result: 'done' });
-        (0, vitest_1.expect)(statusSpy).toHaveBeenCalledTimes(2);
-    });
-    (0, vitest_1.it)('fails when task reports an error status', async () => {
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        vitest_1.vi.spyOn(client, 'getTaskStatus').mockResolvedValue({
-            taskId: 'task',
-            status: 'failed',
-            error: 'boom',
-        });
-        await (0, vitest_1.expect)(client.waitForCompletion('task')).rejects.toThrow('boom');
-    });
-    (0, vitest_1.it)('uses default failure message when status error is missing', async () => {
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        vitest_1.vi.spyOn(client, 'getTaskStatus').mockResolvedValue({
-            taskId: 'task',
-            status: 'failed',
-        });
-        await (0, vitest_1.expect)(client.waitForCompletion('task')).rejects.toThrow('Task failed');
-    });
-    (0, vitest_1.it)('fails when task never completes within max attempts', async () => {
-        vitest_1.vi.useFakeTimers();
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        vitest_1.vi.spyOn(client, 'getTaskStatus').mockResolvedValue({
-            taskId: 'task',
-            status: 'processing',
-        });
-        const promise = client.waitForCompletion('task', 20, 2);
-        const expectation = (0, vitest_1.expect)(promise).rejects.toThrow('Task did not complete within the expected time');
-        await vitest_1.vi.advanceTimersByTimeAsync(20);
-        await vitest_1.vi.advanceTimersByTimeAsync(20);
-        await expectation;
-    });
-    (0, vitest_1.it)('chains runTask through submitTask and waitForCompletion', async () => {
-        const client = new index_1.TaskForceAI({ apiKey: 'key' });
-        const submitSpy = vitest_1.vi.spyOn(client, 'submitTask').mockResolvedValue('task-123');
-        const waitSpy = vitest_1.vi.spyOn(client, 'waitForCompletion').mockResolvedValue({
-            taskId: 'task-123',
-            result: 'ok',
-        });
-        const result = await client.runTask('prompt', { mock: true }, 10, 2);
-        (0, vitest_1.expect)(result).toEqual({ taskId: 'task-123', result: 'ok' });
-        (0, vitest_1.expect)(submitSpy).toHaveBeenCalledWith('prompt', { mock: true });
-        (0, vitest_1.expect)(waitSpy).toHaveBeenCalledWith('task-123', 10, 2);
-    });
-});