@inferencesh/sdk 0.6.13 → 0.6.15

package/README.md

@@ -677,7 +677,7 @@ import type {
 
 - [documentation](https://inference.sh/docs) — getting started guides and api reference
 - [blog](https://inference.sh/blog) — tutorials on ai agents, image generation, and more
-- [app store](https://app.inference.sh) — browse 250+ ai models
+- [app store](https://app.inference.sh) — browse ai models
 - [discord](https://discord.gg/inference) — community support
 - [github](https://github.com/inference-sh) — open source projects
 

package/dist/agent/actions.js

@@ -18,6 +18,14 @@ const dispatchedToolInvocations = new Set();
 // =============================================================================
 export function createActions(ctx) {
     const { client, dispatch, getConfig, getChatId, getClientToolHandlers, getStreamManager, setStreamManager, getStreamEnabled, getPollIntervalMs, callbacks } = ctx;
+    let prevChatWasBusy = false;
+    const checkTurnEnd = (chat) => {
+        const isBusy = chat.status === ChatStatusBusy;
+        if (prevChatWasBusy && !isBusy) {
+            callbacks.onTurnEnd?.(chat);
+        }
+        prevChatWasBusy = isBusy;
+    };
     // =========================================================================
     // Internal helpers
     // =========================================================================
@@ -26,6 +34,7 @@ export function createActions(ctx) {
         if (chat) {
             const status = chat.status === ChatStatusBusy ? 'streaming' : 'idle';
             callbacks.onStatusChange?.(status);
+            checkTurnEnd(chat);
         }
     };
     const updateMessage = (message) => {
@@ -129,6 +138,7 @@ export function createActions(ctx) {
             if (chatData) {
                 const status = chatData.status === ChatStatusBusy ? 'streaming' : 'idle';
                 callbacks.onStatusChange?.(status);
+                checkTurnEnd(chatData);
             }
         });
         // Listen for ChatMessage updates

package/dist/agent/actions.test.js

@@ -1,5 +1,5 @@
 import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
-import { createActions } from './actions';
+import { createActions, getClientToolHandlers } from './actions';
 import * as agentApi from './api';
 import { PollManager } from '../http/poll';
 import { StreamableManager } from '../http/streamable';
@@ -230,6 +230,35 @@ describe('createActions', () => {
             expect(pollInstances[0].options.pollFunction).toBeDefined();
             expect(pollInstances[0].start).toHaveBeenCalled();
         });
+        it('should stop an existing stream manager before starting a new connection', async () => {
+            const { ctx, dispatch } = createTestContext();
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const firstManager = streamInstances[0];
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            expect(firstManager.stop).toHaveBeenCalled();
+            expect(streamInstances).toHaveLength(2);
+            expect(streamInstances[1].start).toHaveBeenCalled();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'connecting',
+            });
+        });
+        it('should dispatch streaming status when the stream manager starts', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onStatusChange } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            streamInstances[0].options.onStart?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'streaming',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('streaming');
+        });
     });
     describe('stopStream', () => {
         it('should clear the manager ref before stop so onEnd does not double-dispatch idle', async () => {
@@ -246,6 +275,19 @@ describe('createActions', () => {
             // Only the explicit stopStream dispatch, not a second from onEnd
             expect(idleDispatches).toHaveLength(1);
         });
+        it('should reset to idle when the stream ends unexpectedly with manager still set', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onStatusChange } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            streamInstances[0].options.onEnd?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'idle',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+        });
         it('should clear the manager ref before poll stop so onStop does not double-dispatch idle', async () => {
             const onStatusChange = jest.fn();
             const { ctx, dispatch, setStreamManager } = createTestContext({
@@ -264,6 +306,22 @@ describe('createActions', () => {
             expect(idleDispatches).toHaveLength(1);
             expect(onStatusChange).toHaveBeenCalledWith('idle');
         });
+        it('should reset to idle when poll transport stops unexpectedly with manager still set', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onStatusChange },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            pollInstances[0].options.onStop?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'idle',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+        });
     });
     describe('stream and poll error callbacks', () => {
         it('should forward stream errors to onError callback', async () => {
@@ -382,6 +440,22 @@ describe('createActions', () => {
         });
     });
     describe('pollChat', () => {
+        it('should dispatch streaming status when the poll manager starts', async () => {
+            const onStatusChange = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onStatusChange },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            pollInstances[0].options.onStart?.();
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'streaming',
+            });
+            expect(onStatusChange).toHaveBeenCalledWith('streaming');
+        });
         it('should fetch full chat when poll status changes', async () => {
             const { ctx: baseCtx } = createTestContext({ getStreamEnabled: () => false });
             const { ctx } = createTestContext({
@@ -715,3 +789,32 @@ describe('createActions', () => {
         });
     });
 });
+describe('getClientToolHandlers', () => {
+    it('returns an empty map when config is null', () => {
+        expect(getClientToolHandlers(null)).toEqual(new Map());
+    });
+    it('returns an empty map for template agent refs', () => {
+        expect(getClientToolHandlers({ agent: 'inference/my-agent' })).toEqual(new Map());
+    });
+    it('returns an empty map when ad-hoc config has no tools', () => {
+        expect(getClientToolHandlers({
+            core_app: { ref: 'openrouter/claude@abc' },
+            system_prompt: 'test',
+        })).toEqual(new Map());
+    });
+    it('extracts client tool handlers from ad-hoc config tools', () => {
+        const handler = jest.fn();
+        const map = getClientToolHandlers({
+            core_app: { ref: 'openrouter/claude@abc' },
+            system_prompt: 'test',
+            tools: [
+                {
+                    schema: { name: 'browser', type: ToolTypeClient, description: 'browse' },
+                    handler,
+                },
+            ],
+        });
+        expect(map.size).toBe(1);
+        expect(map.get('browser')).toBe(handler);
+    });
+});

package/dist/agent/api.test.js

@@ -125,6 +125,15 @@ describe('agent/api', () => {
             const body = JSON.parse(String(runInit.body));
             expect(body.input.attachments).toEqual([fileRecord]);
         });
+        it('should route template agent configs to /agents/run without agent_config', async () => {
+            mockJsonResponse(runResponse);
+            await sendMessage(makeClient(), { agent: 'agent-template-1' }, 'chat-existing', 'hi');
+            const [, init] = mockFetch.mock.calls[0];
+            const body = JSON.parse(String(init.body));
+            expect(body.agent).toBe('agent-template-1');
+            expect(body.chat_id).toBe('chat-existing');
+            expect(body).not.toHaveProperty('agent_config');
+        });
     });
     describe('submitToolResult', () => {
         it('should wrap string results in { result }', async () => {
@@ -143,6 +152,10 @@ describe('agent/api', () => {
             const [, init] = mockFetch.mock.calls[0];
             expect(JSON.parse(String(init.body))).toEqual(payload);
         });
+        it('should rethrow when the request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('submit failed'));
+            await expect(submitToolResult(makeClient(), 'inv-3', 'done')).rejects.toThrow('submit failed');
+        });
     });
     describe('fetchChat', () => {
         it('should return chat data on success', async () => {
@@ -196,6 +209,14 @@ describe('agent/api', () => {
             mockFetch.mockRejectedValueOnce(new Error('approve failed'));
             await expect(approveTool(makeClient(), 'inv-1')).rejects.toThrow('approve failed');
         });
+        it('should rethrow when rejectTool request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('reject failed'));
+            await expect(rejectTool(makeClient(), 'inv-1', 'unsafe')).rejects.toThrow('reject failed');
+        });
+        it('should rethrow when alwaysAllowTool request fails', async () => {
+            mockFetch.mockRejectedValueOnce(new Error('allow failed'));
+            await expect(alwaysAllowTool(makeClient(), 'chat-1', 'inv-1', 'browser_tool')).rejects.toThrow('allow failed');
+        });
     });
     describe('getChatStreamConfig', () => {
         it('should delegate to HttpClient.getStreamableConfig for the chat stream path', () => {

package/dist/agent/provider.d.ts

@@ -27,7 +27,7 @@ import type { AgentChatProviderProps } from './types';
  * }
  * ```
  */
-export declare function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, stream, pollIntervalMs, children, }: AgentChatProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, onTurnEnd, stream, pollIntervalMs, children, }: AgentChatProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace AgentChatProvider {
     var displayName: string;
 }

package/dist/agent/provider.js

@@ -39,7 +39,7 @@ function mergeHandlers(base, extra) {
  * }
  * ```
  */
-export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, stream, pollIntervalMs, children, }) {
+export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandlers: extraHandlers, onChatCreated, onStatusChange, onError, onTurnEnd, stream, pollIntervalMs, children, }) {
     // Core state via useReducer
     const [state, dispatch] = useReducer(chatReducer, initialState);
     // Refs for mutable values that actions need access to
@@ -49,15 +49,15 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
     const streamRef = useRef(stream);
     const pollIntervalMsRef = useRef(pollIntervalMs);
     const clientToolHandlersRef = useRef(mergeHandlers(getClientToolHandlers(agentConfig), extraHandlers));
-    const callbacksRef = useRef({ onChatCreated, onStatusChange, onError });
+    const callbacksRef = useRef({ onChatCreated, onStatusChange, onError, onTurnEnd });
     // Keep refs in sync with props
     useEffect(() => {
         configRef.current = agentConfig;
         clientToolHandlersRef.current = mergeHandlers(getClientToolHandlers(agentConfig), extraHandlers);
     }, [agentConfig, extraHandlers]);
     useEffect(() => {
-        callbacksRef.current = { onChatCreated, onStatusChange, onError };
-    }, [onChatCreated, onStatusChange, onError]);
+        callbacksRef.current = { onChatCreated, onStatusChange, onError, onTurnEnd };
+    }, [onChatCreated, onStatusChange, onError, onTurnEnd]);
     useEffect(() => {
         streamRef.current = stream;
         pollIntervalMsRef.current = pollIntervalMs;
@@ -82,7 +82,7 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
     // Re-bind callbacks when they change
     useEffect(() => {
         actionsContext.callbacks = callbacksRef.current;
-    }, [actionsContext, onChatCreated, onStatusChange, onError]);
+    }, [actionsContext, onChatCreated, onStatusChange, onError, onTurnEnd]);
     const actionsResultRef = useRef(null);
     if (!actionsResultRef.current) {
         actionsResultRef.current = createActions(actionsContext);

package/dist/agent/types.d.ts

@@ -135,6 +135,8 @@ export interface AgentChatProviderProps {
     onStatusChange?: (status: ChatStatus) => void;
     /** Callback when an error occurs */
     onError?: (error: Error) => void;
+    /** Callback when the agent's turn ends (chat transitions from busy to idle/completed) */
+    onTurnEnd?: (chat: ChatDTO) => void;
     /** Use SSE streaming (true, default) or polling (false) for real-time updates */
     stream?: boolean;
     /** Polling interval in ms when stream is false (default: 2000) */
@@ -216,6 +218,7 @@ export interface ActionsContext {
         onChatCreated?: (chatId: string) => void;
         onStatusChange?: (status: ChatStatus) => void;
         onError?: (error: Error) => void;
+        onTurnEnd?: (chat: ChatDTO) => void;
     };
 }
 /**

package/dist/api/agents.test.js

@@ -1,7 +1,7 @@
 import { HttpClient } from '../http/client';
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
-import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
 const mockFetch = jest.fn();
@@ -97,6 +97,40 @@ describe('Agent.sendMessage (polling mode)', () => {
             init.method === 'GET');
         expect(fullChatGets).toHaveLength(2);
     });
+    it('should dispatch onToolCall for in_progress client tool invocations', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-progress',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusInProgress,
+            function: { name: 'my_tool', arguments: { x: 2 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusBusy,
+            chat_messages: [messageWithTool],
+        });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({
+            id: 'chat-1',
+            status: ChatStatusIdle,
+            chat_messages: [messageWithTool],
+        });
+        const onMessage = jest.fn();
+        const onToolCall = jest.fn();
+        await agent().sendMessage('run tool', { stream: false, onMessage, onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        expect(onToolCall).toHaveBeenCalledWith({
+            id: 'tool-inv-progress',
+            name: 'my_tool',
+            args: { x: 2 },
+        });
+    });
     it('should dispatch onToolCall once per client tool invocation', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -188,6 +222,30 @@ describe('Agent.sendMessage (polling mode)', () => {
         const output = await agent().run('no finish tool');
         expect(output).toBeNull();
     });
+    it('should warn on repeated poll errors without resolving sendMessage', async () => {
+        jest.useFakeTimers();
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => { });
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockFetch.mockRejectedValue(new Error('status endpoint down'));
+        const sendPromise = agent().sendMessage('hello', { stream: false });
+        for (let i = 0; i < 6; i++) {
+            await Promise.resolve();
+            jest.advanceTimersByTime(20);
+            await Promise.resolve();
+        }
+        expect(warnSpy).toHaveBeenCalledWith('[Agent] Poll error:', expect.any(Error));
+        let settled = false;
+        sendPromise.then(() => {
+            settled = true;
+        });
+        await Promise.resolve();
+        expect(settled).toBe(false);
+        warnSpy.mockRestore();
+        jest.useRealTimers();
+    });
 });
 describe('Agent.sendMessage (streaming mode)', () => {
     beforeEach(() => {
@@ -220,6 +278,39 @@ describe('Agent.sendMessage (streaming mode)', () => {
         expect(result.userMessage).toEqual(userMessage);
         expect(onChat).toHaveBeenCalledWith(expect.objectContaining({ id: 'chat-1', status: ChatStatusIdle }));
     });
+    it('should dispatch onToolCall for in_progress tools from chat_messages stream events', async () => {
+        const toolInvocation = {
+            id: 'tool-inv-progress',
+            type: ToolTypeClient,
+            status: ToolInvocationStatusInProgress,
+            function: { name: 'my_tool', arguments: { x: 2 } },
+        };
+        const messageWithTool = makeMessage({ tool_invocations: [toolInvocation] });
+        mockFetch.mockImplementation((url) => {
+            if (url.includes('/agents/run')) {
+                return Promise.resolve({
+                    ok: true,
+                    status: 200,
+                    text: () => Promise.resolve(JSON.stringify({
+                        user_message: makeMessage({ id: 'user-1', role: 'user' }),
+                        assistant_message: makeMessage(),
+                    })),
+                });
+            }
+            return Promise.resolve(mockNdjsonStream([
+                `${JSON.stringify({ event: 'chat_messages', data: messageWithTool })}\n`,
+                `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+            ]));
+        });
+        const onToolCall = jest.fn();
+        await streamingAgent().sendMessage('run tool', { onToolCall });
+        expect(onToolCall).toHaveBeenCalledTimes(1);
+        expect(onToolCall).toHaveBeenCalledWith({
+            id: 'tool-inv-progress',
+            name: 'my_tool',
+            args: { x: 2 },
+        });
+    });
     it('should dispatch onToolCall from chat_messages stream events', async () => {
         const toolInvocation = {
             id: 'tool-inv-1',
@@ -714,6 +805,20 @@ describe('Agent.getChat', () => {
         expect(url).toContain('/chats/chat-42');
         expect(init.method).toBe('GET');
     });
+    it('should expose currentChatId after sendMessage establishes a chat', async () => {
+        const agentInstance = agent();
+        mockJsonResponse({
+            user_message: makeMessage({ id: 'user-1', role: 'user' }),
+            assistant_message: makeMessage(),
+        });
+        mockJsonResponse({ status: ChatStatusBusy });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusBusy, chat_messages: [] });
+        mockJsonResponse({ status: ChatStatusIdle });
+        mockJsonResponse({ id: 'chat-1', status: ChatStatusIdle, chat_messages: [] });
+        expect(agentInstance.currentChatId).toBeNull();
+        await agentInstance.sendMessage('hello', { stream: false });
+        expect(agentInstance.currentChatId).toBe('chat-1');
+    });
     it('should GET /chats/{id} with established chat id when chatId is omitted', async () => {
         const agentInstance = agent();
         mockJsonResponse({
@@ -797,6 +902,20 @@ describe('AgentsAPI (template CRUD)', () => {
         expect(url).toContain('/agents/internal-tools');
         expect(init.method).toBe('GET');
     });
+    it('should GET /agents/{id}/card for getA2ACard()', async () => {
+        const card = {
+            name: 'support-bot',
+            description: 'Customer support agent',
+            url: 'https://api.example.com/agents/support-bot',
+            version: '1.0.0',
+        };
+        mockJsonResponse(card);
+        const result = await api().getA2ACard('agent-1');
+        expect(result).toEqual(card);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/card');
+        expect(init.method).toBe('GET');
+    });
     it('should POST team_id for transferOwnership()', async () => {
         const agent = { id: 'agent-1' };
         mockJsonResponse(agent);

package/dist/api/files.test.js

@@ -41,6 +41,14 @@ describe('FilesAPI', () => {
         expect(init.method).toBe('DELETE');
     });
     describe('processInput', () => {
+        it('should return falsy inputs unchanged without uploading', async () => {
+            await expect(api().processInput(null)).resolves.toBeNull();
+            await expect(api().processInput(undefined)).resolves.toBeUndefined();
+            await expect(api().processInput(0)).resolves.toBe(0);
+            await expect(api().processInput(false)).resolves.toBe(false);
+            await expect(api().processInput('')).resolves.toBe('');
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
         it('should not treat short plain strings as base64 file uploads', async () => {
             const result = await api().processInput({ key: 'key1', note: 'hello' });
             expect(result).toEqual({ key: 'key1', note: 'hello' });

package/dist/api/search.test.js

@@ -25,6 +25,17 @@ describe('SearchAPI', () => {
         expect(init.method).toBe('POST');
         expect(JSON.parse(init.body)).toEqual(payload);
     });
+    it('should forward conversation context in suggest() body', async () => {
+        const payload = {
+            query: 'flux',
+            context: 'previous conversation about image generation',
+            limit: 5,
+        };
+        mockJsonResponse({ results: [] });
+        await api().suggest(payload);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
     it('should POST /search for search()', async () => {
         const payload = { q: 'claude', type: 'apps', limit: 5 };
         const response = { hits: [{ id: 'app-1' }] };

package/dist/api/tasks.test.js

@@ -217,6 +217,27 @@ describe('TasksAPI.run (streaming mode)', () => {
         expect(result.status).toBe(TaskStatusCompleted);
         expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ id: 'task-1', status: TaskStatusCompleted }), ['status']);
     });
+    it('should preserve session_id across partial stream updates that omit it', async () => {
+        setupStreamMocks([
+            `${JSON.stringify({
+                data: { status: TaskStatusRunning, id: 'task-1' },
+                fields: ['status'],
+            })}\n`,
+            `${JSON.stringify({
+                data: { status: TaskStatusCompleted, id: 'task-1', output: { ok: true } },
+                fields: ['status', 'output'],
+            })}\n`,
+        ], makeTask({ session_id: 'sess-persist' }));
+        const onPartialUpdate = jest.fn();
+        const result = await api().run({ app: 'test-app', input: {} }, {}, { wait: true, onPartialUpdate });
+        expect(result.session_id).toBe('sess-persist');
+        expect(onPartialUpdate).toHaveBeenCalledWith(expect.objectContaining({ session_id: 'sess-persist', status: TaskStatusRunning }), ['status']);
+        expect(onPartialUpdate).toHaveBeenLastCalledWith(expect.objectContaining({
+            session_id: 'sess-persist',
+            status: TaskStatusCompleted,
+            output: { ok: true },
+        }), ['status', 'output']);
+    });
 });
 describe('TasksAPI.run (HTTP contract)', () => {
     beforeEach(() => {

package/dist/http/poll.test.js

@@ -82,4 +82,65 @@ describe('PollManager', () => {
         await Promise.resolve();
         expect(onData.mock.calls.length).toBe(callsBefore);
     });
+    it('should not run overlapping polls when pollFunction is still in flight', async () => {
+        let resolvePoll = () => { };
+        const pollFunction = jest.fn().mockImplementation(() => new Promise((resolve) => {
+            resolvePoll = resolve;
+        }));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+        });
+        manager.start();
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(1);
+        resolvePoll({ status: 'ok' });
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(pollFunction).toHaveBeenCalledTimes(2);
+        manager.stop();
+    });
+    it('should ignore start() when polling is already active', async () => {
+        const onStart = jest.fn();
+        const pollFunction = jest.fn().mockResolvedValue({});
+        const manager = new PollManager({ pollFunction, onStart });
+        manager.start();
+        manager.start();
+        expect(onStart).toHaveBeenCalledTimes(1);
+        manager.stop();
+    });
+    it('should reset consecutive error count after a successful poll', async () => {
+        const onError = jest.fn();
+        const onStop = jest.fn();
+        const pollFunction = jest
+            .fn()
+            .mockRejectedValueOnce(new Error('fail 1'))
+            .mockResolvedValueOnce({ status: 'ok' })
+            .mockRejectedValueOnce(new Error('fail 2'))
+            .mockRejectedValueOnce(new Error('fail 3'));
+        const manager = new PollManager({
+            pollFunction,
+            intervalMs: 100,
+            maxRetries: 2,
+            onError,
+            onStop,
+        });
+        manager.start();
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onStop).not.toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(1);
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        jest.advanceTimersByTime(100);
+        await Promise.resolve();
+        expect(onStop).toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(3);
+        manager.stop();
+    });
 });

package/dist/http/streamable.test.js

@@ -152,6 +152,18 @@ describe('streamable', () => {
             }
         }).rejects.toThrow('HTTP 401: Unauthorized');
     });
+    it('should throw when the response has no body', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            body: null,
+        });
+        await expect(async () => {
+            for await (const _ of streamable('http://test.com/stream')) {
+                // consume
+            }
+        }).rejects.toThrow('No response body');
+    });
     // Edge cases for chunking/buffering
     describe('chunking edge cases', () => {
         it('should handle message split across many chunks', async () => {
@@ -379,6 +391,68 @@ describe('StreamableManager', () => {
         await manager.start();
         expect(events).toEqual(['start', 'data', 'end']);
     });
+    it('should dispatch typed events to addEventListener subscribers', async () => {
+        global.fetch = mockFetch([
+            '{"event":"chats","data":{"id":"chat-1","status":"busy"}}\n',
+            '{"event":"chat_messages","data":{"id":"msg-1","content":"hi"}}\n',
+        ]);
+        const onChat = jest.fn();
+        const onMessage = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onData: jest.fn(),
+        });
+        manager.addEventListener('chats', onChat);
+        manager.addEventListener('chat_messages', onMessage);
+        await manager.start();
+        expect(onChat).toHaveBeenCalledWith({ id: 'chat-1', status: 'busy' });
+        expect(onMessage).toHaveBeenCalledWith({ id: 'msg-1', content: 'hi' });
+    });
+    it('should stop dispatching to an unsubscribed listener', async () => {
+        global.fetch = mockFetch([
+            '{"event":"chats","data":{"id":"chat-1"}}\n',
+        ]);
+        const removedListener = jest.fn();
+        const activeListener = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+        });
+        const unsubscribe = manager.addEventListener('chats', removedListener);
+        manager.addEventListener('chats', activeListener);
+        unsubscribe();
+        await manager.start();
+        expect(removedListener).not.toHaveBeenCalled();
+        expect(activeListener).toHaveBeenCalledWith({ id: 'chat-1' });
+    });
+    it('should ignore start() when a stream is already running', async () => {
+        let readCount = 0;
+        const mockReader = {
+            read: jest.fn().mockImplementation(async () => {
+                readCount++;
+                if (readCount > 3) {
+                    return { done: true, value: undefined };
+                }
+                await new Promise((resolve) => setTimeout(resolve, 20));
+                return { done: false, value: new TextEncoder().encode('{"id":1}\n') };
+            }),
+            releaseLock: jest.fn(),
+        };
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: true,
+            body: { getReader: () => mockReader },
+        });
+        const onStart = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onStart,
+            onData: () => { },
+        });
+        const firstStart = manager.start();
+        await manager.start();
+        await firstStart;
+        expect(onStart).toHaveBeenCalledTimes(1);
+        expect(global.fetch).toHaveBeenCalledTimes(1);
+    });
     it('should handle stop()', async () => {
         let readCount = 0;
         const mockReader = {
@@ -407,4 +481,30 @@ describe('StreamableManager', () => {
         // Should have stopped before reading all 10
         expect(readCount).toBeLessThan(10);
     });
+    it('should call onError when the stream request fails', async () => {
+        global.fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            status: 503,
+            text: async () => 'Service unavailable',
+        });
+        const onError = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onError,
+        });
+        await manager.start();
+        expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'HTTP 503: Service unavailable' }));
+    });
+    it('should route partial updates to onData when onPartialData is not provided', async () => {
+        global.fetch = mockFetch([
+            '{"data":{"id":1,"status":"busy"},"fields":["status"]}\n',
+        ]);
+        const onData = jest.fn();
+        const manager = new StreamableManager({
+            url: 'http://test.com/stream',
+            onData,
+        });
+        await manager.start();
+        expect(onData).toHaveBeenCalledWith({ id: 1, status: 'busy' });
+    });
 });

package/dist/proxy/index.test.js

@@ -106,6 +106,23 @@ describe('processProxyRequest', () => {
             }),
         }));
     });
+    it('should prefer client Authorization header over env API key', async () => {
+        const target = 'https://api.inference.sh/v1/tasks/1';
+        await processProxyRequest(createTestAdapter({
+            header: (name) => {
+                if (name === INF_TARGET_HEADER)
+                    return target;
+                if (name === 'authorization')
+                    return 'Bearer client-session-token';
+                return undefined;
+            },
+        }));
+        expect(global.fetch).toHaveBeenCalledWith(target, expect.objectContaining({
+            headers: expect.objectContaining({
+                authorization: 'Bearer client-session-token',
+            }),
+        }));
+    });
     it('should use query param fallback when header is missing (SSE clients)', async () => {
         const target = 'https://api.inference.sh/v1/stream';
         const encoded = encodeURIComponent(target);

package/dist/stream.test.js

@@ -34,6 +34,15 @@ describe('StreamManager', () => {
             await manager.connect();
             expect(onStart).toHaveBeenCalled();
         });
+        it('should not call onStart when createEventSource returns null', async () => {
+            const onStart = jest.fn();
+            const manager = new StreamManager({
+                createEventSource: async () => null,
+                onStart,
+            });
+            await manager.connect();
+            expect(onStart).not.toHaveBeenCalled();
+        });
         it('should parse JSON messages and call onData', async () => {
             const onData = jest.fn();
             const manager = new StreamManager({

package/dist/types.d.ts

@@ -506,6 +506,42 @@ export interface CreateApiKeyRequest {
     expires_at?: string;
     scopes?: string[];
 }
+/**
+ * EstimateCostRequest is the request for POST /store/apps/{appId}/estimate.
+ */
+export interface EstimateCostRequest {
+    input: {
+        [key: string]: any;
+    };
+    function?: string;
+}
+/**
+ * EstimateCostResponse is the response from the cost estimation endpoint.
+ */
+export interface EstimateCostResponse {
+    /**
+     * Confidence: "exact" (all fees input-based), "range" (estimate expression),
+     * or "unknown" (output-dependent, no estimate expression).
+     */
+    confidence: string;
+    /**
+     * Microcents is set when confidence is "exact".
+     */
+    microcents?: number;
+    /**
+     * Min/Max are set when confidence is "range".
+     */
+    min?: number;
+    max?: number;
+    /**
+     * DependsOn lists post-execution variables the pricing needs (when not exact).
+     */
+    depends_on?: string[];
+    /**
+     * PricingDescription is the rendered human-readable pricing string.
+     */
+    pricing_description?: string;
+}
 /**
  * Scope represents an API key permission scope string.
  */
@@ -683,7 +719,7 @@ export declare const ScopeBillingRead: Scope;
  */
 export declare const ScopeBillingWrite: Scope;
 /**
- * Action-level scopes for Secrets (sensitive - not in read/run presets)
+ * Action-level scopes for Secrets (sensitive - excluded from read-only preset)
  */
 export declare const ScopeSecretsRead: Scope;
 /**
@@ -794,6 +830,8 @@ export interface ScopePreset {
     label: string;
     description: string;
     scopes: Scope[];
+    summary?: string[];
+    hidden?: boolean;
 }
 /**
  * ApiKeyDTO for API responses
@@ -820,6 +858,19 @@ export interface AppPricing {
     royalty_expression: string;
     partner_expression: string;
     total_expression: string;
+    /**
+     * Estimate is a single CEL expression for pre-execution cost estimation.
+     * Returns either an int (exact total in microcents) or a {"min": int, "max": int} map.
+     * Only has access to pre-execution variables: task_inputs, prices, fees, task_function.
+     * Used by the /estimate endpoint when the real expressions depend on post-execution data.
+     * Not needed when all fee expressions are already input-based (the system evaluates those directly).
+     */
+    estimate?: string;
+    /**
+     * Estimable is computed at save time. True when all fee expressions can be
+     * evaluated from pre-execution data alone (task_inputs, prices, fees, task_function).
+     */
+    estimable?: boolean;
     description: string;
     description_rendered?: string;
 }
@@ -971,6 +1022,7 @@ export interface AppStoreListingDTO {
     max_concurrency: number;
     max_concurrency_per_team: number;
     min_concurrency: number;
+    required_feature?: string;
     tags?: string[];
 }
 /**
@@ -1170,6 +1222,7 @@ export interface EngineDTO extends BaseModelDTO, PermissionModelDTO {
     name: string;
     api_url: string;
     status: EngineStatus;
+    engine_version: string;
     system_info?: SystemInfo;
     workers: (WorkerDTO | undefined)[];
 }
@@ -1264,6 +1317,20 @@ export interface EntitlementDTO extends BaseModelDTO {
     source: EntitlementSource;
     enforcement: EnforcementMode;
     expires_at?: string;
+    team_plan_id?: string;
+}
+/**
+ * EntitlementErrorMeta is the structured metadata returned in entitlement error responses.
+ */
+export interface EntitlementErrorMeta {
+    resource: EntitlementResource;
+    resource_label?: string;
+    limit?: number;
+    current?: number;
+    upgrade_available: boolean;
+    addon_plan_id?: string;
+    addon_plan_name?: string;
+    addon_plan_price?: number;
 }
 /**
  * FileMetadata holds probed media metadata cached on File records.
@@ -1590,6 +1657,7 @@ export interface KnowledgeVersionDTO extends BaseModelDTO {
     content_hash: string;
     description: string;
     tags: string[];
+    scope?: string[];
     metadata?: {
         [key: string]: string;
     };
@@ -1819,11 +1887,14 @@ export interface PlanDTO extends BaseModelDTO {
     display_order: number;
     active: boolean;
     self_serve?: boolean;
+    plan_type: PlanType;
     price_monthly?: number;
     price_yearly?: number;
     credits_monthly: number;
     provider_price_id_monthly?: string;
     provider_price_id_yearly?: string;
+    required_plan_ids?: string[];
+    required_plan_names?: string[];
     limits: PlanLimits;
 }
 /**
@@ -1854,6 +1925,7 @@ export interface RefRouteDTO extends BaseModelDTO {
     alias_ref: string;
     target_ref: string;
     primary: boolean;
+    mode: RefRouteMode;
     description: string;
     enabled: boolean;
 }
@@ -1879,6 +1951,7 @@ export interface KnowledgeVersionInput {
     content?: KnowledgeFile;
     files?: KnowledgeFile[];
     tags?: string[];
+    scope?: string[];
     metadata?: {
         [key: string]: string;
     };
@@ -1983,9 +2056,11 @@ export interface UpdateIntegrationScopesRequest {
  */
 export interface SuggestRequest {
     query: string;
+    context?: string;
     limit?: number;
     category?: string;
     agent?: boolean;
+    scope?: string[];
 }
 /**
  * SuggestResponse is the output of the suggest endpoint.
@@ -1999,6 +2074,7 @@ export interface SuggestResponse {
  */
 export interface SuggestResult {
     type: string;
+    tag?: string;
     name: string;
     description: string;
     command: string;
@@ -2084,7 +2160,6 @@ export interface SecretDTO extends BaseModelDTO, PermissionModelDTO {
  */
 export interface SubscriptionDTO extends BaseModelDTO {
     team_id: string;
-    stripe_subscription_id?: string;
     plan_id: string;
     plan?: PlanDTO;
     interval: SubscriptionInterval;
@@ -2620,6 +2695,21 @@ export declare const SubscriptionStatusPaused: SubscriptionStatus;
 export type SubscriptionInterval = string;
 export declare const SubscriptionIntervalMonthly: SubscriptionInterval;
 export declare const SubscriptionIntervalYearly: SubscriptionInterval;
+export type PlanType = string;
+export declare const PlanTypeBase: PlanType;
+export declare const PlanTypeAddon: PlanType;
+export type EntitlementSource = string;
+export declare const EntitlementSourceTier: EntitlementSource;
+export declare const EntitlementSourceOverride: EntitlementSource;
+export declare const EntitlementSourceWhitelist: EntitlementSource;
+export declare const EntitlementSourceTrial: EntitlementSource;
+export declare const EntitlementSourceAddon: EntitlementSource;
+export type EntitlementType = string;
+export declare const EntitlementTypeBoolean: EntitlementType;
+export declare const EntitlementTypeLimit: EntitlementType;
+export type EnforcementMode = string;
+export declare const EnforcementBlock: EnforcementMode;
+export declare const EnforcementWarn: EnforcementMode;
 export type ChatStatus = string;
 export declare const ChatStatusBusy: ChatStatus;
 export declare const ChatStatusIdle: ChatStatus;
@@ -2871,6 +2961,9 @@ export declare const GraphEdgeTypeParent: GraphEdgeType;
 export declare const GraphEdgeTypeAncestor: GraphEdgeType;
 export declare const GraphEdgeTypeDuplicate: GraphEdgeType;
 export declare const GraphEdgeTypeReferences: GraphEdgeType;
+export declare const GraphEdgeTypeSupersedes: GraphEdgeType;
+export declare const GraphEdgeTypeInput: GraphEdgeType;
+export declare const GraphEdgeTypeOutput: GraphEdgeType;
 /**
  * SecretScope defines the visibility/purpose of a secret
  */
@@ -2887,20 +2980,6 @@ export declare const SecretScopeInternal: SecretScope;
  * SecretScopeSystem is a global system setting, owned by system team, admin-only
  */
 export declare const SecretScopeSystem: SecretScope;
-export type EntitlementSource = string;
-export declare const EntitlementSourceTier: EntitlementSource;
-export declare const EntitlementSourceOverride: EntitlementSource;
-export declare const EntitlementSourceWhitelist: EntitlementSource;
-export declare const EntitlementSourceTrial: EntitlementSource;
-export type EntitlementType = string;
-export declare const EntitlementTypeBoolean: EntitlementType;
-export declare const EntitlementTypeLimit: EntitlementType;
-/**
- * EnforcementMode controls how limit violations are handled.
- */
-export type EnforcementMode = string;
-export declare const EnforcementBlock: EnforcementMode;
-export declare const EnforcementWarn: EnforcementMode;
 export type PageStatus = number;
 export declare const PageStatusUnknown: PageStatus;
 export declare const PageStatusDraft: PageStatus;
@@ -3029,6 +3108,9 @@ export type RefRouteType = string;
 export declare const RefRouteTypeApp: RefRouteType;
 export declare const RefRouteTypeAgent: RefRouteType;
 export declare const RefRouteTypeSkill: RefRouteType;
+export type RefRouteMode = string;
+export declare const RefRouteModeRewrite: RefRouteMode;
+export declare const RefRouteModeRedirect: RefRouteMode;
 export type KnowledgeType = string;
 export declare const KnowledgeTypeConcept: KnowledgeType;
 export declare const KnowledgeTypeSkill: KnowledgeType;
@@ -3102,6 +3184,7 @@ export declare const ResourceTaskExecutions: EntitlementResource;
  * Feature gates — only what has real cost/complexity
  */
 export declare const ResourceFeatureBYOK: EntitlementResource;
+export declare const ResourceFeatureSeedance: EntitlementResource;
 /**
  * Legacy feature gates — kept for DB compatibility, no longer gated
  */
@@ -3242,6 +3325,10 @@ export declare const NotificationTypeSecurityAlert: NotificationType;
  */
 export declare const NotificationTypeTaskComplete: NotificationType;
 export declare const NotificationTypeTaskFailed: NotificationType;
+/**
+ * Data export
+ */
+export declare const NotificationTypeDataExport: NotificationType;
 /**
  * System notifications
  */

package/dist/types.js

@@ -172,7 +172,7 @@ export const ScopeBillingRead = "billing:read";
  */
 export const ScopeBillingWrite = "billing:write";
 /**
- * Action-level scopes for Secrets (sensitive - not in read/run presets)
+ * Action-level scopes for Secrets (sensitive - excluded from read-only preset)
  */
 export const ScopeSecretsRead = "secrets:read";
 /**
@@ -285,6 +285,17 @@ export const SubscriptionStatusCanceled = "canceled";
 export const SubscriptionStatusPaused = "paused";
 export const SubscriptionIntervalMonthly = "monthly";
 export const SubscriptionIntervalYearly = "yearly";
+export const PlanTypeBase = "base";
+export const PlanTypeAddon = "addon";
+export const EntitlementSourceTier = "tier";
+export const EntitlementSourceOverride = "override";
+export const EntitlementSourceWhitelist = "whitelist";
+export const EntitlementSourceTrial = "trial";
+export const EntitlementSourceAddon = "addon";
+export const EntitlementTypeBoolean = "boolean";
+export const EntitlementTypeLimit = "limit";
+export const EnforcementBlock = "block";
+export const EnforcementWarn = "warn";
 export const ChatStatusBusy = "busy";
 export const ChatStatusIdle = "idle";
 export const ChatStatusAwaitingInput = "awaiting_input";
@@ -355,6 +366,9 @@ export const GraphEdgeTypeParent = "parent";
 export const GraphEdgeTypeAncestor = "ancestor";
 export const GraphEdgeTypeDuplicate = "duplicate";
 export const GraphEdgeTypeReferences = "references";
+export const GraphEdgeTypeSupersedes = "supersedes";
+export const GraphEdgeTypeInput = "input";
+export const GraphEdgeTypeOutput = "output";
 /**
  * SecretScopeTeam is a normal user secret, visible in team secret lists
  */
@@ -367,14 +381,6 @@ export const SecretScopeInternal = "internal";
  * SecretScopeSystem is a global system setting, owned by system team, admin-only
  */
 export const SecretScopeSystem = "system";
-export const EntitlementSourceTier = "tier";
-export const EntitlementSourceOverride = "override";
-export const EntitlementSourceWhitelist = "whitelist";
-export const EntitlementSourceTrial = "trial";
-export const EntitlementTypeBoolean = "boolean";
-export const EntitlementTypeLimit = "limit";
-export const EnforcementBlock = "block";
-export const EnforcementWarn = "warn";
 export const PageStatusUnknown = 0;
 export const PageStatusDraft = 1;
 export const PageStatusPublished = 2;
@@ -464,6 +470,8 @@ export const TeamInviteStatusRevoked = "revoked";
 export const RefRouteTypeApp = "app";
 export const RefRouteTypeAgent = "agent";
 export const RefRouteTypeSkill = "skill";
+export const RefRouteModeRewrite = "rewrite";
+export const RefRouteModeRedirect = "redirect";
 export const KnowledgeTypeConcept = "concept";
 export const KnowledgeTypeSkill = "skill";
 export const KnowledgeTypeObservation = "observation";
@@ -528,6 +536,7 @@ export const ResourceTaskExecutions = "task_executions";
  * Feature gates — only what has real cost/complexity
  */
 export const ResourceFeatureBYOK = "feature:byok";
+export const ResourceFeatureSeedance = "feature:seedance";
 /**
  * Legacy feature gates — kept for DB compatibility, no longer gated
  */
@@ -638,6 +647,10 @@ export const NotificationTypeSecurityAlert = "security_alert";
  */
 export const NotificationTypeTaskComplete = "task_complete";
 export const NotificationTypeTaskFailed = "task_failed";
+/**
+ * Data export
+ */
+export const NotificationTypeDataExport = "data_export";
 /**
  * System notifications
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",