@inferencesh/sdk 0.6.10 → 0.6.12

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

@@ -391,6 +391,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();

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)
     // ==========================================================================

package/dist/api/agents.test.js

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import { StreamableManager } from '../http/streamable';
 import { ChatStatusBusy, ChatStatusIdle, ToolInvocationStatusAwaitingInput, ToolTypeClient, } from '../types';
 import { FilesAPI } from './files';
 import { AgentsAPI } from './agents';
@@ -281,6 +282,44 @@ describe('Agent.sendMessage (file attachments)', () => {
         expect(mockFetch.mock.calls.filter(([url]) => String(url).includes('/files')).length).toBe(0);
     });
 });
+describe('Agent.sendMessage (ad-hoc config)', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const adHocAgent = () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: false,
+            pollIntervalMs: 20,
+        });
+        return new AgentsAPI(http, new FilesAPI(http)).create({
+            core_app: { ref: 'openrouter/claude@latest' },
+            system_prompt: 'You are helpful',
+            name: 'adhoc-bot',
+        });
+    };
+    it('should POST agent_config and agent_name instead of agent template ref', async () => {
+        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: [] });
+        await adHocAgent().sendMessage('hello', { stream: false });
+        const runCall = mockFetch.mock.calls.find(([url]) => String(url).includes('/agents/run'));
+        const body = JSON.parse(String(runCall[1].body));
+        expect(body.agent).toBeUndefined();
+        expect(body.agent_config).toEqual({
+            core_app: { ref: 'openrouter/claude@latest' },
+            system_prompt: 'You are helpful',
+            name: 'adhoc-bot',
+        });
+        expect(body.agent_name).toBe('adhoc-bot');
+        expect(body.input.text).toBe('hello');
+    });
+});
 describe('Agent lifecycle', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -317,6 +356,66 @@ describe('Agent lifecycle', () => {
         await agentInstance.stopChat();
         expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/chats/chat-1/stop'), expect.anything());
     });
+    it('disconnect should stop active stream managers', async () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: true,
+            pollIntervalMs: 20,
+        });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+        const stopSpy = jest.spyOn(StreamableManager.prototype, 'stop');
+        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: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+            ]));
+        });
+        await agentInstance.sendMessage('hello', { onChat: jest.fn() });
+        agentInstance.disconnect();
+        expect(stopSpy).toHaveBeenCalled();
+        stopSpy.mockRestore();
+    });
+    it('startStreaming should no-op when there is no active chat', () => {
+        const agentInstance = agent();
+        agentInstance.startStreaming();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it('startStreaming should open the chat stream when chatId exists', async () => {
+        const http = new HttpClient({
+            apiKey: 'test-key',
+            stream: true,
+            pollIntervalMs: 20,
+        });
+        const agentInstance = new AgentsAPI(http, new FilesAPI(http)).create('my-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: [],
+        });
+        await agentInstance.sendMessage('hello', { stream: false });
+        jest.clearAllMocks();
+        mockFetch.mockResolvedValue(mockNdjsonStream([
+            `${JSON.stringify({ event: 'chats', data: { id: 'chat-1', status: ChatStatusIdle } })}\n`,
+        ]));
+        agentInstance.startStreaming({ onChat: jest.fn() });
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/chats/chat-1/stream'), expect.anything());
+    });
     it('reset should clear chat state so stopChat is a no-op', async () => {
         const agentInstance = agent();
         mockJsonResponse({
@@ -338,6 +437,29 @@ describe('Agent lifecycle', () => {
         expect(mockFetch).not.toHaveBeenCalled();
     });
 });
+describe('Agent.getChat', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const agent = () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        return new AgentsAPI(http, new FilesAPI(http)).create('my-agent');
+    };
+    it('should return null without a chat id and no active chat', async () => {
+        const result = await agent().getChat();
+        expect(result).toBeNull();
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+    it('should GET /chats/{id} when chatId is provided', async () => {
+        const chat = { id: 'chat-42', status: 'idle', chat_messages: [] };
+        mockJsonResponse(chat);
+        const result = await agent().getChat('chat-42');
+        expect(result).toEqual(chat);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/chats/chat-42');
+        expect(init.method).toBe('GET');
+    });
+});
 describe('Agent.submitToolResult', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -356,6 +478,23 @@ describe('Agent.submitToolResult', () => {
         expect(body.result).toBe(JSON.stringify(payload));
     });
 });
+describe('AgentsAPI.submitToolResult', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => {
+        const http = new HttpClient({ apiKey: 'test-key' });
+        return new AgentsAPI(http, new FilesAPI(http));
+    };
+    it('should POST plain string results to /tools/{invocationId}', async () => {
+        mockJsonResponse(null);
+        await api().submitToolResult('inv-plain', 'done');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/tools/inv-plain');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(String(init.body))).toEqual({ result: 'done' });
+    });
+});
 describe('AgentsAPI (template CRUD)', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -392,4 +531,80 @@ describe('AgentsAPI (template CRUD)', () => {
         expect(init.method).toBe('POST');
         expect(JSON.parse(init.body)).toEqual(payload);
     });
+    it('should GET /agents/{namespace}/{name} for getByName()', async () => {
+        const agent = { id: 'agent-1', name: 'my-agent' };
+        mockJsonResponse(agent);
+        const result = await api().getByName('inference', 'my-agent');
+        expect(result).toEqual(agent);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/inference/my-agent');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /agents/list for list()', async () => {
+        const page = { items: [{ id: 'agent-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list({ limit: 10 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should GET /agents/{id} for get()', async () => {
+        const agent = { id: 'agent-1', name: 'support-bot' };
+        mockJsonResponse(agent);
+        const result = await api().get('agent-1');
+        expect(result).toEqual(agent);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST /agents/{id} for update()', async () => {
+        const agent = { id: 'agent-1', name: 'updated' };
+        mockJsonResponse(agent);
+        const result = await api().update('agent-1', { name: 'updated' });
+        expect(result).toEqual(agent);
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ name: 'updated' });
+    });
+    it('should DELETE /agents/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('agent-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /agents/{id}/duplicate for duplicate()', async () => {
+        const agent = { id: 'agent-copy' };
+        mockJsonResponse(agent);
+        const result = await api().duplicate('agent-1');
+        expect(result).toEqual(agent);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/duplicate');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /agents/{id}/versions/list for listVersions()', async () => {
+        const page = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().listVersions('agent-1', { limit: 5 });
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 5 });
+    });
+    it('should GET /agents/{id}/versions/{versionId} for getVersion()', async () => {
+        const version = { id: 'ver-1', agent_id: 'agent-1' };
+        mockJsonResponse(version);
+        const result = await api().getVersion('agent-1', 'ver-1');
+        expect(result).toEqual(version);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/agents/agent-1/versions/ver-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const agent = { id: 'agent-1', visibility: 'team' };
+        mockJsonResponse(agent);
+        await api().updateVisibility('agent-1', 'team');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'team' });
+    });
 });

package/dist/api/api-keys.d.ts

@@ -0,0 +1,24 @@
+import { HttpClient } from '../http/client';
+import { ApiKeyDTO, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * API Keys API
+ */
+export declare class ApiKeysAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List API keys with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<ApiKeyDTO>>;
+    /**
+     * Create an API key
+     */
+    create(data: {
+        name: string;
+        scopes?: string[];
+    }): Promise<ApiKeyDTO>;
+    /**
+     * Delete an API key
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/api/api-keys.js

@@ -0,0 +1,26 @@
+/**
+ * API Keys API
+ */
+export class ApiKeysAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List API keys with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/apikeys/list', { data: params });
+    }
+    /**
+     * Create an API key
+     */
+    async create(data) {
+        return this.http.request('post', '/apikeys', { data });
+    }
+    /**
+     * Delete an API key
+     */
+    async delete(id) {
+        return this.http.request('delete', `/apikeys/${id}`);
+    }
+}

package/dist/api/api-keys.test.d.ts

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

package/dist/api/api-keys.test.js

@@ -0,0 +1,44 @@
+import { HttpClient } from '../http/client';
+import { ApiKeysAPI } from './api-keys';
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+function mockJsonResponse(body) {
+    mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify(body)),
+    });
+}
+describe('ApiKeysAPI', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const api = () => new ApiKeysAPI(new HttpClient({ apiKey: 'test-key' }));
+    it('should POST /apikeys/list for list()', async () => {
+        const page = { items: [{ id: 'key-1', name: 'CI' }], next_cursor: null };
+        mockJsonResponse(page);
+        const result = await api().list();
+        expect(result).toEqual(page);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apikeys/list');
+        expect(init.method).toBe('POST');
+    });
+    it('should POST /apikeys for create()', async () => {
+        const payload = { name: 'deploy-bot', scopes: ['tasks:read'] };
+        const key = { id: 'key-new', ...payload, key: 'inf_sk_abc' };
+        mockJsonResponse(key);
+        const result = await api().create(payload);
+        expect(result).toEqual(key);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apikeys');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual(payload);
+    });
+    it('should DELETE /apikeys/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('key-9');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apikeys/key-9');
+        expect(init.method).toBe('DELETE');
+    });
+});

package/dist/api/apps.js

@@ -87,7 +87,7 @@ export class AppsAPI {
      * Set the current (active) version of an app
      */
     async setCurrentVersion(appId, versionId) {
-        return this.http.request('post', `/apps/${appId}/current-version`, { data: { version_id: versionId } });
+        return this.http.request('put', `/apps/${appId}/versions/${versionId}/current`);
     }
 }
 export function createAppsAPI(http) {

package/dist/api/apps.test.js

@@ -48,12 +48,13 @@ describe('AppsAPI', () => {
         const [, init] = mockFetch.mock.calls[0];
         expect(JSON.parse(init.body)).toEqual({ license: 'key-abc' });
     });
-    it('should POST version_id for setCurrentVersion()', async () => {
+    it('should PUT /apps/{id}/versions/{versionId}/current for setCurrentVersion()', async () => {
         const app = { id: 'app-1', current_version_id: 'ver-2' };
         mockJsonResponse(app);
         await api().setCurrentVersion('app-1', 'ver-2');
-        const [, init] = mockFetch.mock.calls[0];
-        expect(JSON.parse(init.body)).toEqual({ version_id: 'ver-2' });
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/ver-2/current');
+        expect(init.method).toBe('PUT');
     });
     it('should POST /apps/{id}/duplicate for duplicate()', async () => {
         const app = { id: 'app-copy' };
@@ -64,4 +65,71 @@ describe('AppsAPI', () => {
         expect(url).toContain('/apps/app-1/duplicate');
         expect(init.method).toBe('POST');
     });
+    it('should GET /apps/{id} for get()', async () => {
+        const app = { id: 'app-1', name: 'demo' };
+        mockJsonResponse(app);
+        const result = await api().get('app-1');
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(init.method).toBe('GET');
+    });
+    it('should GET versioned app for getByVersionId()', async () => {
+        const app = { id: 'app-1', version_id: 'ver-1' };
+        mockJsonResponse(app);
+        const result = await api().getByVersionId('app-1', 'ver-1');
+        expect(result).toEqual(app);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/ver-1');
+    });
+    it('should POST /apps for create()', async () => {
+        const app = { id: 'app-new', name: 'New App' };
+        mockJsonResponse(app);
+        const result = await api().create({ name: 'New App' });
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps');
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'New App' });
+    });
+    it('should POST /apps/{id} for update()', async () => {
+        const app = { id: 'app-1', description: 'updated' };
+        mockJsonResponse(app);
+        const result = await api().update('app-1', { description: 'updated' });
+        expect(result).toEqual(app);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(JSON.parse(init.body)).toEqual({ description: 'updated' });
+    });
+    it('should DELETE /apps/{id} for delete()', async () => {
+        mockJsonResponse(null);
+        await api().delete('app-1');
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1');
+        expect(init.method).toBe('DELETE');
+    });
+    it('should POST /apps/{id}/versions/list for listVersions()', async () => {
+        const versions = { items: [{ id: 'ver-1' }], next_cursor: null };
+        mockJsonResponse(versions);
+        const result = await api().listVersions('app-1', { limit: 20 });
+        expect(result).toEqual(versions);
+        const [url, init] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/versions/list');
+        expect(JSON.parse(init.body)).toEqual({ limit: 20 });
+    });
+    it('should POST visibility for updateVisibility()', async () => {
+        const app = { id: 'app-1', visibility: 'private' };
+        mockJsonResponse(app);
+        await api().updateVisibility('app-1', 'private');
+        const [, init] = mockFetch.mock.calls[0];
+        expect(JSON.parse(init.body)).toEqual({ visibility: 'private' });
+    });
+    it('should GET /apps/{id}/license for getLicense()', async () => {
+        const license = { app_id: 'app-1', license: 'MIT' };
+        mockJsonResponse(license);
+        const result = await api().getLicense('app-1');
+        expect(result).toEqual(license);
+        const [url] = mockFetch.mock.calls[0];
+        expect(url).toContain('/apps/app-1/license');
+    });
 });

package/dist/api/chats.d.ts

@@ -26,5 +26,19 @@ export declare class ChatsAPI {
      * Get chat trace (for debugging/observability)
      */
     getTrace(chatId: string): Promise<ChatTraceDTO>;
+    /**
+     * Get chat status
+     */
+    getStatus(chatId: string): Promise<{
+        status: string;
+    }>;
+    /**
+     * Stop chat generation
+     */
+    stop(chatId: string): Promise<void>;
+    /**
+     * Stream chat updates
+     */
+    stream(chatId: string): Promise<import("eventsource").EventSource | null>;
 }
 export declare function createChatsAPI(http: HttpClient): ChatsAPI;

package/dist/api/chats.js

@@ -35,6 +35,24 @@ export class ChatsAPI {
     async getTrace(chatId) {
         return this.http.request('get', `/chats/${chatId}/trace`);
     }
+    /**
+     * Get chat status
+     */
+    async getStatus(chatId) {
+        return this.http.request('get', `/chats/${chatId}/status`);
+    }
+    /**
+     * Stop chat generation
+     */
+    async stop(chatId) {
+        return this.http.request('post', `/chats/${chatId}/stop`);
+    }
+    /**
+     * Stream chat updates
+     */
+    stream(chatId) {
+        return this.http.createEventSource(`/chats/${chatId}/stream`);
+    }
 }
 export function createChatsAPI(http) {
     return new ChatsAPI(http);