@inferencesh/sdk 0.6.14 → 0.6.19

package/dist/streamable.integration.test.js

@@ -1,150 +0,0 @@
-/**
- * Integration tests for streamable HTTP client
- *
- * Tests NDJSON streaming against the real API.
- * Run with: INFERENCE_API_KEY=xxx npm run test:integration
- *
- * Note: Format negotiation tests may be skipped if server doesn't support NDJSON yet.
- *
- * @jest-environment node
- */
-import { streamable, StreamableManager } from './http/streamable';
-import { Inference, TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled } from './index';
-const isTerminalStatus = (status) => status === TaskStatusCompleted || status === TaskStatusFailed || status === TaskStatusCancelled;
-const API_KEY = process.env.INFERENCE_API_KEY;
-const BASE_URL = process.env.INFERENCE_BASE_URL || 'https://api.inference.sh';
-// Simple test app that completes quickly
-const TEST_APP = 'infsh/text-templating@53bk0yzk';
-const describeIfApiKey = API_KEY ? describe : describe.skip;
-describeIfApiKey('Streamable Integration Tests', () => {
-    let client;
-    beforeAll(() => {
-        client = new Inference({
-            apiKey: API_KEY,
-            baseUrl: BASE_URL,
-        });
-    });
-    describe('Format Negotiation', () => {
-        it('should negotiate format based on Accept header', async () => {
-            // Create a task using the SDK
-            const task = await client.run({ app: TEST_APP, input: { template: 'Format {1}!', strings: ['Test'] } }, { wait: false });
-            // Test NDJSON request
-            const ndjsonRes = await fetch(`${BASE_URL}/tasks/${task.id}/stream`, {
-                headers: {
-                    'Authorization': `Bearer ${API_KEY}`,
-                    'Accept': 'application/x-ndjson',
-                },
-            });
-            expect(ndjsonRes.ok).toBe(true);
-            const ndjsonContentType = ndjsonRes.headers.get('content-type');
-            // Test SSE request
-            const sseRes = await fetch(`${BASE_URL}/tasks/${task.id}/stream`, {
-                headers: {
-                    'Authorization': `Bearer ${API_KEY}`,
-                    'Accept': 'text/event-stream',
-                },
-            });
-            expect(sseRes.ok).toBe(true);
-            const sseContentType = sseRes.headers.get('content-type');
-            // Log what we got for debugging
-            console.log('NDJSON request Content-Type:', ndjsonContentType);
-            console.log('SSE request Content-Type:', sseContentType);
-            // At minimum, SSE should work
-            expect(sseContentType).toContain('text/event-stream');
-            // If NDJSON is supported, it should return NDJSON content-type
-            // Otherwise it falls back to SSE (server not yet updated)
-            const supportsNDJSON = ndjsonContentType?.includes('application/x-ndjson');
-            if (supportsNDJSON) {
-                console.log('✓ Server supports NDJSON format negotiation');
-            }
-            else {
-                console.log('⚠ Server does not yet support NDJSON, falling back to SSE');
-            }
-            // Clean up - consume the streams
-            for (const res of [ndjsonRes, sseRes]) {
-                const reader = res.body?.getReader();
-                if (reader) {
-                    while (true) {
-                        const { done } = await reader.read();
-                        if (done)
-                            break;
-                    }
-                }
-            }
-        }, 60000);
-    });
-    describe('streamable() with NDJSON server', () => {
-        // These tests require the server to support NDJSON
-        // Skip if server doesn't support it yet
-        it('should stream task updates when server supports NDJSON', async () => {
-            // Create a task using the SDK (fire and forget)
-            const task = await client.run({ app: TEST_APP, input: { template: 'Hello {1}!', strings: ['Streamable'] } }, { wait: false });
-            expect(task.id).toBeDefined();
-            // Stream updates using streamable - will request NDJSON format
-            const updates = [];
-            try {
-                for await (const update of streamable(`${BASE_URL}/tasks/${task.id}/stream`, {
-                    headers: { 'Authorization': `Bearer ${API_KEY}` },
-                })) {
-                    updates.push(update);
-                    // Stop when task reaches terminal status
-                    if (isTerminalStatus(update.status))
-                        break;
-                }
-            }
-            catch (err) {
-                // If server doesn't support NDJSON, streamable will fail to parse SSE
-                console.log('⚠ Skipping - server returned non-NDJSON:', err.message);
-                return;
-            }
-            expect(updates.length).toBeGreaterThan(0);
-            // Last update should be terminal
-            const lastUpdate = updates[updates.length - 1];
-            expect(isTerminalStatus(lastUpdate.status)).toBe(true);
-        }, 60000);
-    });
-    describe('StreamableManager with NDJSON server', () => {
-        it('should receive updates via callbacks when server supports NDJSON', async () => {
-            // Create a task using the SDK
-            const task = await client.run({ app: TEST_APP, input: { template: 'Manager {1}!', strings: ['Test'] } }, { wait: false });
-            const updates = [];
-            let started = false;
-            let ended = false;
-            let error = null;
-            const manager = new StreamableManager({
-                url: `${BASE_URL}/tasks/${task.id}/stream`,
-                headers: { 'Authorization': `Bearer ${API_KEY}` },
-                onStart: () => { started = true; },
-                onEnd: () => { ended = true; },
-                onData: (data) => {
-                    updates.push(data);
-                    // Stop when terminal
-                    if (isTerminalStatus(data.status)) {
-                        manager.stop();
-                    }
-                },
-                onError: (err) => {
-                    error = err;
-                },
-            });
-            await manager.start();
-            // If server doesn't support NDJSON, we'll get a parse error
-            if (error) {
-                console.log('⚠ Skipping StreamableManager test - server returned non-NDJSON');
-                return;
-            }
-            expect(started).toBe(true);
-            expect(ended).toBe(true);
-            expect(updates.length).toBeGreaterThan(0);
-        }, 60000);
-    });
-});
-// Ensure Jest doesn't complain when API key is not set
-describe('Streamable Integration Setup', () => {
-    it('checks for API key', () => {
-        if (!API_KEY) {
-            console.log('⚠️  Skipping streamable integration tests - INFERENCE_API_KEY not set');
-        }
-        expect(true).toBe(true);
-    });
-});

package/dist/tool-builder.test.d.ts

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

package/dist/tool-builder.test.js

@@ -1,407 +0,0 @@
-import { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
-import { ToolTypeClient, ToolTypeApp, ToolTypeAgent, ToolTypeHook, ToolTypeHTTP, ToolTypeMCP, IntegrationProviderGoogle, IntegrationProviderGoogleSA, } from './types';
-describe('Schema Helpers', () => {
-    describe('string', () => {
-        it('creates string schema without description', () => {
-            const schema = string();
-            expect(schema).toEqual({ type: 'string' });
-        });
-        it('creates string schema with description', () => {
-            const schema = string('User name');
-            expect(schema).toEqual({ type: 'string', description: 'User name' });
-        });
-    });
-    describe('number', () => {
-        it('creates number schema', () => {
-            expect(number()).toEqual({ type: 'number' });
-            expect(number('Temperature')).toEqual({ type: 'number', description: 'Temperature' });
-        });
-    });
-    describe('integer', () => {
-        it('creates integer schema', () => {
-            expect(integer()).toEqual({ type: 'integer' });
-            expect(integer('Age')).toEqual({ type: 'integer', description: 'Age' });
-        });
-    });
-    describe('boolean', () => {
-        it('creates boolean schema', () => {
-            expect(boolean()).toEqual({ type: 'boolean' });
-            expect(boolean('Is active')).toEqual({ type: 'boolean', description: 'Is active' });
-        });
-    });
-    describe('enumOf', () => {
-        it('creates enum schema', () => {
-            const schema = enumOf(['low', 'medium', 'high']);
-            expect(schema).toEqual({ type: 'string', enum: ['low', 'medium', 'high'] });
-        });
-        it('creates enum schema with description', () => {
-            const schema = enumOf(['a', 'b'], 'Priority level');
-            expect(schema).toEqual({ type: 'string', enum: ['a', 'b'], description: 'Priority level' });
-        });
-    });
-    describe('object', () => {
-        it('creates object schema with nested properties', () => {
-            const schema = object({
-                name: string('Name'),
-                age: integer('Age'),
-            });
-            expect(schema).toEqual({
-                type: 'object',
-                properties: {
-                    name: { type: 'string', description: 'Name' },
-                    age: { type: 'integer', description: 'Age' },
-                },
-            });
-        });
-        it('creates object schema with description', () => {
-            const schema = object({ x: number() }, 'Coordinates');
-            expect(schema.description).toBe('Coordinates');
-        });
-    });
-    describe('array', () => {
-        it('creates array schema', () => {
-            const schema = array(string('Tag'));
-            expect(schema).toEqual({
-                type: 'array',
-                items: { type: 'string', description: 'Tag' },
-            });
-        });
-        it('creates array schema with description', () => {
-            const schema = array(integer(), 'List of IDs');
-            expect(schema).toEqual({
-                type: 'array',
-                items: { type: 'integer' },
-                description: 'List of IDs',
-            });
-        });
-    });
-    describe('optional', () => {
-        it('marks schema as optional', () => {
-            const schema = optional(string('Optional field'));
-            expect(schema).toEqual({ type: 'string', description: 'Optional field', optional: true });
-        });
-        it('preserves original schema properties', () => {
-            const schema = optional(enumOf(['a', 'b'], 'Choice'));
-            expect(schema.enum).toEqual(['a', 'b']);
-            expect(schema.optional).toBe(true);
-        });
-    });
-});
-describe('ClientToolBuilder (tool)', () => {
-    it('creates minimal tool', () => {
-        const t = tool('my_tool').build();
-        expect(t).toEqual({
-            name: 'my_tool',
-            display_name: 'my_tool',
-            description: '',
-            type: ToolTypeClient,
-            require_approval: undefined,
-            client: {
-                input_schema: { type: 'object', properties: {}, required: [] },
-            },
-        });
-    });
-    it('creates tool with description', () => {
-        const t = tool('greet').describe('Says hello').build();
-        expect(t.description).toBe('Says hello');
-    });
-    it('creates tool with display name', () => {
-        const t = tool('get_data').display('Get Data').build();
-        expect(t.display_name).toBe('Get Data');
-    });
-    it('creates tool with displayName alias', () => {
-        const t = tool('get_data').displayName('Get Data').build();
-        expect(t.display_name).toBe('Get Data');
-    });
-    it('returns schema and handler from handler()', async () => {
-        const clientTool = tool('greet')
-            .describe('Say hi')
-            .param('name', string('Name'))
-            .handler(async (args) => `Hello, ${args.name}`);
-        expect(clientTool.schema.name).toBe('greet');
-        expect(await clientTool.handler({ name: 'Ada' })).toBe('Hello, Ada');
-    });
-    it('creates tool with parameters', () => {
-        const t = tool('add')
-            .param('a', number('First number'))
-            .param('b', number('Second number'))
-            .build();
-        expect(t.client?.input_schema).toEqual({
-            type: 'object',
-            properties: {
-                a: { type: 'number', description: 'First number' },
-                b: { type: 'number', description: 'Second number' },
-            },
-            required: ['a', 'b'],
-        });
-    });
-    it('handles optional parameters correctly', () => {
-        const t = tool('search')
-            .param('query', string('Search query'))
-            .param('limit', optional(integer('Max results')))
-            .build();
-        expect(t.client?.input_schema.required).toEqual(['query']);
-        expect(t.client?.input_schema.properties).toHaveProperty('limit');
-    });
-    it('creates tool with require approval', () => {
-        const t = tool('dangerous').requireApproval().build();
-        expect(t.require_approval).toBe(true);
-    });
-    it('creates tool with nested object parameters', () => {
-        const t = tool('create_user')
-            .param('user', object({
-            name: string('Name'),
-            email: string('Email'),
-        }, 'User data'))
-            .build();
-        const schema = t.client?.input_schema;
-        expect(schema?.properties?.user).toMatchObject({
-            type: 'object',
-            properties: {
-                name: { type: 'string', description: 'Name' },
-                email: { type: 'string', description: 'Email' },
-            },
-            required: ['name', 'email'],
-        });
-    });
-    it('propagates required into nested objects with optional fields', () => {
-        const t = tool('update_user')
-            .param('user', object({
-            name: string('Name'),
-            bio: optional(string('Bio')),
-        }))
-            .build();
-        const userProp = t.client?.input_schema.properties?.user;
-        expect(userProp.required).toEqual(['name']);
-    });
-    it('creates tool with array parameters', () => {
-        const t = tool('process_items')
-            .param('items', array(string('Item'), 'List of items'))
-            .build();
-        expect(t.client?.input_schema.properties?.items).toMatchObject({
-            type: 'array',
-            items: { type: 'string', description: 'Item' },
-        });
-    });
-});
-describe('AppToolBuilder (appTool)', () => {
-    it('creates app tool with reference', () => {
-        const t = appTool('generate', 'infsh/flux@v1.0')
-            .describe('Generate image')
-            .build();
-        expect(t.type).toBe(ToolTypeApp);
-        expect(t.app).toEqual({ ref: 'infsh/flux@v1.0' });
-        expect(t.description).toBe('Generate image');
-    });
-    it('handles app reference with latest version', () => {
-        const t = appTool('browse', 'my-org/browser@latest').build();
-        expect(t.app).toEqual({ ref: 'my-org/browser@latest' });
-    });
-    it('includes parameters', () => {
-        const t = appTool('fetch', 'infsh/fetch@v1')
-            .param('url', string('URL to fetch'))
-            .build();
-        expect(t.name).toBe('fetch');
-        // Note: App tools don't use client input_schema, params are for documentation
-    });
-    it('supports function selection for multi-function apps', () => {
-        const t = appTool('upscale', 'infsh/sdxl@v1')
-            .function('upscale')
-            .describe('Upscale an image')
-            .build();
-        expect(t.app?.function).toBe('upscale');
-    });
-    it('supports session enabled for stateful apps', () => {
-        const t = appTool('browser', 'infsh/browser-use@v1')
-            .sessionEnabled()
-            .describe('Control a browser')
-            .build();
-        expect(t.app?.session_enabled).toBe(true);
-    });
-    it('supports full configuration with function and session', () => {
-        const t = appTool('chat', 'infsh/chatbot@v1')
-            .describe('Chat with context')
-            .function('stream')
-            .sessionEnabled()
-            .setup({ api_key: 'secret' })
-            .input({ temperature: 0.7 })
-            .build();
-        expect(t.app).toEqual({
-            ref: 'infsh/chatbot@v1',
-            function: 'stream',
-            session_enabled: true,
-            setup: { api_key: 'secret' },
-            input: { temperature: 0.7 },
-        });
-    });
-});
-describe('AgentToolBuilder (agentTool)', () => {
-    it('creates agent tool with reference', () => {
-        const t = agentTool('research', 'acme/researcher@v2')
-            .describe('Research a topic')
-            .build();
-        expect(t.type).toBe(ToolTypeAgent);
-        expect(t.agent).toEqual({ ref: 'acme/researcher@v2' });
-    });
-    it('supports display name and approval', () => {
-        const t = agentTool('coder', 'infsh/code-agent@latest')
-            .display('Code Assistant')
-            .requireApproval()
-            .build();
-        expect(t.display_name).toBe('Code Assistant');
-        expect(t.require_approval).toBe(true);
-    });
-});
-describe('HTTPToolBuilder (httpTool)', () => {
-    it('includes custom method and headers in the built tool', () => {
-        const t = httpTool('fetch', 'https://api.example.com/data')
-            .method('GET')
-            .header('X-Custom', '1')
-            .build();
-        expect(t.http?.method).toBe('GET');
-        expect(t.http?.headers).toEqual({ 'X-Custom': '1' });
-    });
-    it('omits method when POST is the default', () => {
-        const t = httpTool('post', 'https://api.example.com').build();
-        expect(t.http?.method).toBeUndefined();
-    });
-    it('should attach integration auth with provider and integration id', () => {
-        const t = httpTool('gmail_send', 'https://api.example.com/send')
-            .auth({ integration: IntegrationProviderGoogle, integrationId: 'int-123' })
-            .build();
-        expect(t.type).toBe(ToolTypeHTTP);
-        expect(t.http?.auth).toEqual({
-            type: 'integration',
-            provider: IntegrationProviderGoogle,
-            integration_id: 'int-123',
-        });
-    });
-    it('should attach integration auth for google-sa service account provider', () => {
-        const t = httpTool('calendar_read', 'https://api.example.com/calendar')
-            .auth({ integration: IntegrationProviderGoogleSA, integrationId: 'sa-int-1' })
-            .build();
-        expect(t.http?.auth).toEqual({
-            type: 'integration',
-            provider: IntegrationProviderGoogleSA,
-            integration_id: 'sa-int-1',
-        });
-    });
-    it('should attach api key auth with default header', () => {
-        const t = httpTool('fetch', 'https://api.example.com').auth({ apiKey: 'KEY' }).build();
-        expect(t.http?.auth).toEqual({
-            type: 'api_key',
-            secret: 'KEY',
-            header: 'X-API-Key',
-        });
-    });
-    it('should attach bearer auth', () => {
-        const t = httpTool('fetch', 'https://api.example.com')
-            .auth({ bearer: 'token-abc' })
-            .build();
-        expect(t.http?.auth).toEqual({
-            type: 'bearer',
-            secret: 'token-abc',
-        });
-    });
-    it('callTool should be an alias for httpTool', () => {
-        const t = callTool('ping', 'https://api.example.com/ping').method('GET').build();
-        expect(t.type).toBe(ToolTypeHTTP);
-        expect(t.http?.method).toBe('GET');
-    });
-});
-describe('MCPToolBuilder (mcpTool)', () => {
-    it('creates MCP tool with integration and tool name', () => {
-        const t = mcpTool('search_docs', 'int-mcp-1', 'search').describe('Search docs').build();
-        expect(t.type).toBe(ToolTypeMCP);
-        expect(t.mcp).toEqual({ integration_id: 'int-mcp-1', tool_name: 'search' });
-        expect(t.description).toBe('Search docs');
-    });
-});
-describe('WebhookToolBuilder (webhookTool)', () => {
-    it('creates webhook tool with URL', () => {
-        const t = webhookTool('notify', 'https://api.example.com/webhook')
-            .describe('Send notification')
-            .build();
-        expect(t.type).toBe(ToolTypeHook);
-        expect(t.hook?.url).toBe('https://api.example.com/webhook');
-        expect(t.description).toBe('Send notification');
-    });
-    it('includes secret key', () => {
-        const t = webhookTool('slack', 'https://hooks.slack.com/services/xxx')
-            .secret('SLACK_SECRET')
-            .build();
-        expect(t.hook?.secret).toBe('SLACK_SECRET');
-    });
-    it('generates input schema for parameters', () => {
-        const t = webhookTool('send', 'https://api.example.com')
-            .param('message', string('Message'))
-            .param('priority', optional(enumOf(['low', 'high'])))
-            .build();
-        expect(t.hook?.input_schema).toEqual({
-            type: 'object',
-            properties: {
-                message: { type: 'string', description: 'Message' },
-                priority: { type: 'string', enum: ['low', 'high'] },
-            },
-            required: ['message'],
-        });
-    });
-});
-describe('InternalToolsBuilder (internalTools)', () => {
-    it('creates empty config by default', () => {
-        const config = internalTools().build();
-        expect(config).toEqual({});
-    });
-    it('enables plan tools', () => {
-        const config = internalTools().plan().build();
-        expect(config).toEqual({ plan: true });
-    });
-    it('enables memory tools', () => {
-        const config = internalTools().memory().build();
-        expect(config).toEqual({ memory: true });
-    });
-    it('enables widget tools', () => {
-        const config = internalTools().widget().build();
-        expect(config).toEqual({ widget: true });
-    });
-    it('enables finish tool', () => {
-        const config = internalTools().finish().build();
-        expect(config).toEqual({ finish: true });
-    });
-    it('chains multiple tool enables', () => {
-        const config = internalTools().plan().memory().widget().build();
-        expect(config).toEqual({ plan: true, memory: true, widget: true });
-    });
-    it('enables all tools with all()', () => {
-        const config = internalTools().all().build();
-        expect(config).toEqual({ plan: true, memory: true, widget: true, finish: true });
-    });
-    it('disables all tools with none()', () => {
-        const config = internalTools().none().build();
-        expect(config).toEqual({ plan: false, memory: false, widget: false, finish: false });
-    });
-    it('allows explicit disable', () => {
-        const config = internalTools().plan(false).memory(true).build();
-        expect(config).toEqual({ plan: false, memory: true });
-    });
-});
-describe('Fluent API chaining', () => {
-    it('supports full fluent chain', () => {
-        const t = tool('complex')
-            .display('Complex Tool')
-            .describe('A complex tool with many params')
-            .param('name', string('Name'))
-            .param('count', integer('Count'))
-            .param('options', optional(object({
-            verbose: boolean('Verbose mode'),
-            tags: array(string('Tag')),
-        })))
-            .requireApproval()
-            .build();
-        expect(t.name).toBe('complex');
-        expect(t.display_name).toBe('Complex Tool');
-        expect(t.description).toBe('A complex tool with many params');
-        expect(t.require_approval).toBe(true);
-        expect(t.client?.input_schema.required).toEqual(['name', 'count']);
-    });
-});

package/dist/utils.test.d.ts

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

package/dist/utils.test.js

@@ -1,43 +0,0 @@
-import { TaskStatusCancelled, TaskStatusCompleted, TaskStatusFailed, TaskStatusRunning, TaskStatusUnknown, } from './types';
-import { isTerminalStatus, parseStatus } from './utils';
-describe('parseStatus', () => {
-    it('should return TaskStatusUnknown for null and undefined', () => {
-        expect(parseStatus(null)).toBe(TaskStatusUnknown);
-        expect(parseStatus(undefined)).toBe(TaskStatusUnknown);
-    });
-    it('should pass through numeric status values', () => {
-        expect(parseStatus(TaskStatusRunning)).toBe(TaskStatusRunning);
-        expect(parseStatus(TaskStatusCompleted)).toBe(TaskStatusCompleted);
-    });
-    it('should map lowercase string status names to TaskStatus', () => {
-        expect(parseStatus('running')).toBe(TaskStatusRunning);
-        expect(parseStatus('completed')).toBe(TaskStatusCompleted);
-        expect(parseStatus('failed')).toBe(TaskStatusFailed);
-        expect(parseStatus('cancelled')).toBe(TaskStatusCancelled);
-    });
-    it('should be case-insensitive for string statuses', () => {
-        expect(parseStatus('COMPLETED')).toBe(TaskStatusCompleted);
-        expect(parseStatus('Running')).toBe(TaskStatusRunning);
-    });
-    it('should return TaskStatusUnknown for unrecognized strings', () => {
-        expect(parseStatus('not_a_real_status')).toBe(TaskStatusUnknown);
-    });
-    it('should return TaskStatusUnknown for non-string non-number values', () => {
-        expect(parseStatus(true)).toBe(TaskStatusUnknown);
-    });
-});
-describe('isTerminalStatus', () => {
-    it('should be true for completed, failed, and cancelled (int or string)', () => {
-        expect(isTerminalStatus(TaskStatusCompleted)).toBe(true);
-        expect(isTerminalStatus(TaskStatusFailed)).toBe(true);
-        expect(isTerminalStatus(TaskStatusCancelled)).toBe(true);
-        expect(isTerminalStatus('completed')).toBe(true);
-        expect(isTerminalStatus('failed')).toBe(true);
-        expect(isTerminalStatus('cancelled')).toBe(true);
-    });
-    it('should be false for non-terminal statuses', () => {
-        expect(isTerminalStatus(TaskStatusRunning)).toBe(false);
-        expect(isTerminalStatus('running')).toBe(false);
-        expect(isTerminalStatus(null)).toBe(false);
-    });
-});