@inferencesh/sdk 0.6.10 → 0.6.13

package/README.md

@@ -7,7 +7,7 @@
 
 official javascript/typescript sdk for [inference.sh](https://inference.sh) — the ai agent runtime for serverless ai inference.
 
-run ai models, build ai agents, and deploy generative ai applications with a simple api. access 250+ models including flux, stable diffusion, llms (claude, gpt, gemini), video generation (veo, seedance), and more.
+run ai models, build ai agents, and deploy generative ai applications with a simple api. access models including flux, stable diffusion, llms (claude, gpt, gemini), video generation (veo, seedance), and more.
 
 ## Installation
 

package/dist/agent/actions.js

@@ -4,7 +4,7 @@
  * Action creators that handle side effects (API calls, streaming).
  * These are created once per provider instance with access to dispatch.
  */
-import { ToolInvocationStatusAwaitingInput, ToolTypeClient, ChatStatusBusy, } from '../types';
+import { ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, ChatStatusBusy, } from '../types';
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
 import { isAdHocConfig, extractClientToolHandlers } from './types';
@@ -35,12 +35,12 @@ export function createActions(ctx) {
         if (chatId && message.chat_id !== chatId && !message.chat_id.startsWith(chatId))
             return;
         dispatch({ type: 'UPDATE_MESSAGE', payload: message });
-        // Check for client tool invocations that need execution
+        // Dispatch client tool handlers when ready (in_progress or awaiting_input for backwards compat)
         const clientToolHandlers = getClientToolHandlers();
         if (message.tool_invocations && chatId && clientToolHandlers.size > 0) {
             for (const invocation of message.tool_invocations) {
                 if (invocation.type === ToolTypeClient &&
-                    invocation.status === ToolInvocationStatusAwaitingInput) {
+                    (invocation.status === ToolInvocationStatusInProgress || invocation.status === ToolInvocationStatusAwaitingInput)) {
                     // Skip if already dispatched
                     if (dispatchedToolInvocations.has(invocation.id)) {
                         continue;

package/dist/agent/actions.test.js

@@ -1,4 +1,4 @@
-import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
+import { ChatStatusBusy, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
 import { createActions } from './actions';
 import * as agentApi from './api';
 import { PollManager } from '../http/poll';
@@ -94,6 +94,12 @@ describe('createActions', () => {
         mockAgentApi.approveTool.mockResolvedValue(undefined);
         mockAgentApi.rejectTool.mockResolvedValue(undefined);
         mockAgentApi.alwaysAllowTool.mockResolvedValue(undefined);
+        mockAgentApi.uploadFile.mockResolvedValue({
+            id: 'file-1',
+            uri: 'inf://files/uploaded',
+            filename: 'notes.txt',
+            content_type: 'text/plain',
+        });
     });
     describe('updateMessage (via stream listeners)', () => {
         it('should ignore messages for a different chat when IDs do not prefix-match', async () => {
@@ -141,6 +147,30 @@ describe('createActions', () => {
             expect(handler).toHaveBeenCalledWith({ x: 1 });
             expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-ok', 'tool ok');
         });
+        it('should dispatch client tool handlers when status is in_progress', async () => {
+            const handler = jest.fn().mockResolvedValue('in progress ok');
+            const { ctx } = createTestContext({
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onMessage = streamInstances[0].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            onMessage(makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-progress',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusInProgress,
+                        function: { name: 'my_tool', arguments: { y: 2 } },
+                    },
+                ],
+            }));
+            await Promise.resolve();
+            expect(handler).toHaveBeenCalledWith({ y: 2 });
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-progress', 'in progress ok');
+        });
         it('should submit a JSON error when a client tool handler throws', async () => {
             const handler = jest.fn().mockRejectedValue(new Error('handler boom'));
             const { ctx } = createTestContext({
@@ -216,6 +246,49 @@ describe('createActions', () => {
             // Only the explicit stopStream dispatch, not a second from onEnd
             expect(idleDispatches).toHaveLength(1);
         });
+        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({
+                getStreamEnabled: () => false,
+                callbacks: { onStatusChange },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const manager = pollInstances[0];
+            internalActions.stopStream();
+            expect(setStreamManager).toHaveBeenCalledWith(undefined);
+            expect(manager.stop).toHaveBeenCalled();
+            manager.options.onStop?.();
+            const idleDispatches = dispatch.mock.calls.filter(([action]) => action.type === 'SET_CONNECTION_STATUS' && action.payload === 'idle');
+            expect(idleDispatches).toHaveLength(1);
+            expect(onStatusChange).toHaveBeenCalledWith('idle');
+        });
+    });
+    describe('stream and poll error callbacks', () => {
+        it('should forward stream errors to onError callback', async () => {
+            const onError = jest.fn();
+            const { ctx } = createTestContext({ callbacks: { onError } });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const streamError = new Error('stream connection lost');
+            streamInstances[0].options.onError?.(streamError);
+            expect(onError).toHaveBeenCalledWith(streamError);
+        });
+        it('should forward poll manager errors to onError callback', async () => {
+            const onError = jest.fn();
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                callbacks: { onError },
+            });
+            const { internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const pollError = new Error('poll transport failed');
+            pollInstances[0].options.onError?.(pollError);
+            expect(onError).toHaveBeenCalledWith(pollError);
+        });
     });
     describe('publicActions.sendMessage', () => {
         it('should call onChatCreated and start streaming for a new chat', async () => {
@@ -265,6 +338,19 @@ describe('createActions', () => {
             await publicActions.sendMessage('   ');
             expect(mockAgentApi.sendMessage).not.toHaveBeenCalled();
         });
+        it('should no-op when agent config is missing', async () => {
+            const consoleError = jest.spyOn(console, 'error').mockImplementation(() => { });
+            const { ctx, dispatch } = createTestContext({ getConfig: () => null });
+            const { publicActions } = createActions(ctx);
+            await publicActions.sendMessage('hello');
+            expect(mockAgentApi.sendMessage).not.toHaveBeenCalled();
+            expect(dispatch).not.toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'streaming',
+            });
+            expect(consoleError).toHaveBeenCalledWith('[AgentSDK] No agent config provided');
+            consoleError.mockRestore();
+        });
     });
     describe('streamChat error handling', () => {
         it('should reset to idle when initial fetchChat fails', async () => {
@@ -348,6 +434,77 @@ describe('createActions', () => {
             await Promise.resolve();
             expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'poll fetch failed' }));
         });
+        it('should not refetch chat when poll status is unchanged', async () => {
+            const { ctx: baseCtx } = createTestContext({ getStreamEnabled: () => false });
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                client: {
+                    ...baseCtx.client,
+                    http: { ...baseCtx.client.http, request: jest.fn().mockResolvedValue({ status: ChatStatusBusy }) },
+                },
+            });
+            const { internalActions } = createActions(ctx);
+            mockAgentApi.fetchChat.mockResolvedValue({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [],
+            });
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            await pollInstances[0].options.onData?.({ status: ChatStatusBusy });
+            await Promise.resolve();
+            const fetchCountAfterFirst = mockAgentApi.fetchChat.mock.calls.length;
+            await pollInstances[0].options.onData?.({ status: ChatStatusBusy });
+            await Promise.resolve();
+            expect(mockAgentApi.fetchChat).toHaveBeenCalledTimes(fetchCountAfterFirst);
+        });
+        it('should dispatch client tools from poll path when status changes', async () => {
+            const handler = jest.fn().mockResolvedValue('poll ok');
+            const toolMessage = makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-poll',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusInProgress,
+                        function: { name: 'my_tool', arguments: { y: 2 } },
+                    },
+                ],
+            });
+            const { ctx: baseCtx } = createTestContext({
+                getStreamEnabled: () => false,
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+            });
+            const { ctx } = createTestContext({
+                getStreamEnabled: () => false,
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+                client: {
+                    ...baseCtx.client,
+                    http: {
+                        ...baseCtx.client.http,
+                        request: jest.fn().mockResolvedValue({ status: ChatStatusBusy }),
+                    },
+                },
+            });
+            const { internalActions } = createActions(ctx);
+            mockAgentApi.fetchChat
+                .mockResolvedValueOnce({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [],
+            })
+                .mockResolvedValueOnce({
+                id: 'chat-full-id-123',
+                status: ChatStatusBusy,
+                chat_messages: [toolMessage],
+            });
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            await pollInstances[0].options.onData?.({ status: 'idle' });
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledWith({ y: 2 });
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledWith(ctx.client, 'tool-inv-poll', 'poll ok');
+        });
     });
     describe('client tool deduplication', () => {
         it('should not submit the same client tool invocation twice', async () => {
@@ -378,6 +535,14 @@ describe('createActions', () => {
         });
     });
     describe('publicActions lifecycle', () => {
+        it('uploadFile should delegate to the API layer', async () => {
+            const file = new File(['hello'], 'notes.txt', { type: 'text/plain' });
+            const { ctx } = createTestContext();
+            const { publicActions } = createActions(ctx);
+            const result = await publicActions.uploadFile(file);
+            expect(mockAgentApi.uploadFile).toHaveBeenCalledWith(ctx.client, file);
+            expect(result).toEqual(expect.objectContaining({ uri: 'inf://files/uploaded', filename: 'notes.txt' }));
+        });
         it('reset should stop stream and dispatch RESET', async () => {
             const { ctx, dispatch } = createTestContext();
             const { publicActions } = createActions(ctx);
@@ -391,6 +556,12 @@ describe('createActions', () => {
             publicActions.stopGeneration();
             expect(mockAgentApi.stopChat).toHaveBeenCalledWith(ctx.client, 'chat-short');
         });
+        it('stopGeneration should no-op when there is no chatId', () => {
+            const { ctx } = createTestContext({ getChatId: () => null });
+            const { publicActions } = createActions(ctx);
+            publicActions.stopGeneration();
+            expect(mockAgentApi.stopChat).not.toHaveBeenCalled();
+        });
         it('submitToolResult should set error state when API fails', async () => {
             mockAgentApi.submitToolResult.mockRejectedValueOnce(new Error('submit failed'));
             const onError = jest.fn();
@@ -416,6 +587,38 @@ describe('createActions', () => {
                 payload: 'idle',
             });
         });
+        it('reset should allow the same client tool invocation to dispatch again', async () => {
+            const handler = jest.fn().mockResolvedValue('ok');
+            const { ctx } = createTestContext({
+                getClientToolHandlers: () => new Map([['my_tool', handler]]),
+            });
+            const { publicActions, internalActions } = createActions(ctx);
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onMessage = streamInstances[0].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            const toolMessage = makeMessage({
+                chat_id: 'chat-short',
+                tool_invocations: [
+                    {
+                        id: 'tool-inv-reset',
+                        type: ToolTypeClient,
+                        status: ToolInvocationStatusAwaitingInput,
+                        function: { name: 'my_tool', arguments: {} },
+                    },
+                ],
+            });
+            onMessage(toolMessage);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledTimes(1);
+            publicActions.reset();
+            internalActions.streamChat('chat-full-id-123');
+            await Promise.resolve();
+            const onMessageAfterReset = streamInstances[1].addEventListener.mock.calls.find(([event]) => event === 'chat_messages')?.[1];
+            onMessageAfterReset(toolMessage);
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(handler).toHaveBeenCalledTimes(2);
+            expect(mockAgentApi.submitToolResult).toHaveBeenCalledTimes(2);
+        });
     });
     describe('HIL tool actions', () => {
         it('approveTool should delegate to the API', async () => {
@@ -454,6 +657,33 @@ describe('createActions', () => {
             });
             expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'approve failed' }));
         });
+        it('rejectTool should set error state when API fails', async () => {
+            mockAgentApi.rejectTool.mockRejectedValueOnce(new Error('reject failed'));
+            const onError = jest.fn();
+            const { ctx, dispatch } = createTestContext({ callbacks: { onError } });
+            const { publicActions } = createActions(ctx);
+            await expect(publicActions.rejectTool('inv-1', 'unsafe')).rejects.toThrow('reject failed');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'error',
+            });
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'reject failed' }));
+        });
+        it('alwaysAllowTool should set error state when API fails', async () => {
+            mockAgentApi.alwaysAllowTool.mockRejectedValueOnce(new Error('allow failed'));
+            const onError = jest.fn();
+            const { ctx, dispatch } = createTestContext({
+                getChatId: () => 'chat-short',
+                callbacks: { onError },
+            });
+            const { publicActions } = createActions(ctx);
+            await expect(publicActions.alwaysAllowTool('inv-1', 'my_tool')).rejects.toThrow('allow failed');
+            expect(dispatch).toHaveBeenCalledWith({
+                type: 'SET_CONNECTION_STATUS',
+                payload: 'error',
+            });
+            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'allow failed' }));
+        });
     });
     describe('setChatId', () => {
         it('should no-op when the chat id is unchanged', async () => {

package/dist/agent/api.test.js

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import { FilesAPI } from '../api/files';
-import { sendAdHocMessage, sendTemplateMessage, sendMessage, submitToolResult, approveTool, rejectTool, alwaysAllowTool, fetchChat, stopChat, getChatStreamConfig, } from './api';
+import { sendAdHocMessage, sendTemplateMessage, sendMessage, submitToolResult, approveTool, rejectTool, alwaysAllowTool, fetchChat, stopChat, getChatStreamConfig, uploadFile, } from './api';
 import { ToolTypeClient } from '../types';
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -205,4 +205,21 @@ describe('agent/api', () => {
             expect(config.headers).toEqual(expect.objectContaining({ Authorization: expect.stringContaining('Bearer') }));
         });
     });
+    describe('uploadFile', () => {
+        it('should delegate to client.files.upload and return the uploaded file ref', async () => {
+            const client = makeClient();
+            const fileRecord = {
+                id: 'file-1',
+                uri: 'inf://files/uploaded',
+                filename: 'notes.txt',
+                content_type: 'text/plain',
+            };
+            const uploadSpy = jest.spyOn(client.files, 'upload').mockResolvedValue(fileRecord);
+            const file = new File(['hello'], 'notes.txt', { type: 'text/plain' });
+            const result = await uploadFile(client, file);
+            expect(uploadSpy).toHaveBeenCalledWith(file);
+            expect(result).toEqual(fileRecord);
+            uploadSpy.mockRestore();
+        });
+    });
 });

package/dist/api/agents.d.ts

@@ -144,10 +144,20 @@ export declare class AgentsAPI {
      * Get a specific agent version
      */
     getVersion(agentId: string, versionId: string): Promise<AgentVersionDTO>;
+    /**
+     * Get an agent by namespace/name (e.g., "inference/my-agent")
+     */
+    getByName(namespace: string, name: string): Promise<AgentDTO>;
     /**
      * Get internal tools for the agent
      */
     getInternalTools(): Promise<InternalToolDefinition[]>;
+    /**
+     * Get A2A protocol agent card for an agent.
+     * Returns raw JSON (not wrapped in {data:...}) for direct upload to GCP Producer Portal.
+     * Spec: https://a2a-protocol.org/latest/specification/
+     */
+    getA2ACard(agentId: string): Promise<Record<string, unknown>>;
     /**
      * Create an agent instance for chat interactions
      */

package/dist/api/agents.js

@@ -1,6 +1,6 @@
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
-import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ChatStatusBusy, } from '../types';
+import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ChatStatusBusy, } from '../types';
 /**
  * Agent for chat interactions
  *
@@ -166,7 +166,7 @@ export class Agent {
                     for (const inv of message.tool_invocations) {
                         if (this.dispatchedToolCalls.has(inv.id))
                             continue;
-                        if (inv.type === ToolTypeClient && inv.status === ToolInvocationStatusAwaitingInput) {
+                        if (inv.type === ToolTypeClient && (inv.status === ToolInvocationStatusInProgress || inv.status === ToolInvocationStatusAwaitingInput)) {
                             this.dispatchedToolCalls.add(inv.id);
                             options.onToolCall({
                                 id: inv.id,
@@ -222,7 +222,7 @@ export class Agent {
                                 for (const inv of message.tool_invocations) {
                                     if (this.dispatchedToolCalls.has(inv.id))
                                         continue;
-                                    if (inv.type === ToolTypeClient && inv.status === ToolInvocationStatusAwaitingInput) {
+                                    if (inv.type === ToolTypeClient && (inv.status === ToolInvocationStatusInProgress || inv.status === ToolInvocationStatusAwaitingInput)) {
                                         this.dispatchedToolCalls.add(inv.id);
                                         options.onToolCall({
                                             id: inv.id,
@@ -319,12 +319,26 @@ export class AgentsAPI {
     async getVersion(agentId, versionId) {
         return this.http.request('get', `/agents/${agentId}/versions/${versionId}`);
     }
+    /**
+     * Get an agent by namespace/name (e.g., "inference/my-agent")
+     */
+    async getByName(namespace, name) {
+        return this.http.request('get', `/agents/${namespace}/${name}`);
+    }
     /**
      * Get internal tools for the agent
      */
     async getInternalTools() {
         return this.http.request('get', '/agents/internal-tools');
     }
+    /**
+     * Get A2A protocol agent card for an agent.
+     * Returns raw JSON (not wrapped in {data:...}) for direct upload to GCP Producer Portal.
+     * Spec: https://a2a-protocol.org/latest/specification/
+     */
+    async getA2ACard(agentId) {
+        return this.http.request('get', `/agents/${agentId}/card`);
+    }
     // ==========================================================================
     // Agent Runtime (chat interactions)
     // ==========================================================================