taskforceai-sdk 1.2.0 → 1.2.1

package/README.md

@@ -22,19 +22,19 @@ 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
 }
 ```
 
@@ -75,7 +75,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 +155,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,21 @@
-/**
- * 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);
-}
+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?;
+    constructor(o: TaskForceAIOptions);
+    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;AAOlC,qBAAa,WAAW;IACtB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,CAAC,CAAS;IAClB,OAAO,CAAC,EAAE,CAAC,CAAwB;gBACvB,CAAC,EAAE,kBAAkB;IAOjC,OAAO,CAAC,GAAG,CAOP;IAEE,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,86 @@
 "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);
+});
 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;
+    constructor(o) {
+        this.req = (e, i = {}, r = false) => (0, transport_1.makeRequest)(e, i, { apiKey: this.ak, baseUrl: this.url, timeout: this.t, responseHook: this.rh }, r, transport_1.transportDefaults.maxRetries);
+        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;
     }
-    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);
-            }
-            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'}`);
-        }
+    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;
     }
-    /**
-     * 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');
-        }
-        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 (openRouterKey) {
-            payload.openRouterKey = openRouterKey;
-        }
-        const response = await this.makeRequest('/run', {
-            method: 'POST',
-            body: JSON.stringify(payload),
-        });
-        return response.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 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 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}`);
     }
-    /**
-     * 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 *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,19 @@
+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,EAAE,MAAM;gBAD1B,OAAO,EAAE,MAAM,EACR,UAAU,CAAC,EAAE,MAAM,YAAA;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,GAAU,CAAC,EACjC,UAAU,MAAM,EAChB,SAAS,WAAW,EACpB,4CAA4C,eAAe,EAC3D,mBAAiB,EACjB,mBAAgC,KAC/B,OAAO,CAAC,CAAC,CAyDX,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,32 @@
+export declare const VERSION = "1.2.1";
+export interface TaskForceAIOptions {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    responseHook?: TaskResponseHook;
+}
+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,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACjC;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.2.1",
+  "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/grok4fastheavy.git"
   },
   "bugs": {
     "url": "https://github.com/ClayWarren/grok4fastheavy/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);
-    });
-});