@inferencesh/sdk 0.4.21 → 0.4.23

package/README.md

@@ -24,19 +24,21 @@ Get your API key from the [inference.sh dashboard](https://app.inference.sh/sett
 ## Quick Start
 
 ```typescript
-import { inference } from '@inferencesh/sdk';
+import { inference, TaskStatusCompleted } from '@inferencesh/sdk';
 
 const client = inference({ apiKey: 'your-api-key' });
 
 // Run a task and wait for the result
-const result = await client.run({
+const result = await client.tasks.run({
   app: 'your-app',
   input: {
     prompt: 'Hello, world!'
   }
 });
 
-console.log(result.output);
+if (result.status === TaskStatusCompleted) {
+  console.log(result.output);
+}
 ```
 
 ## Usage
@@ -44,17 +46,19 @@ console.log(result.output);
 ### Basic Usage
 
 ```typescript
-import { inference } from '@inferencesh/sdk';
+import { inference, TaskStatusCompleted } from '@inferencesh/sdk';
 
 const client = inference({ apiKey: 'your-api-key' });
 
 // Wait for result (default behavior)
-const result = await client.run({
+const result = await client.tasks.run({
   app: 'my-app',
   input: { prompt: 'Generate something amazing' }
 });
 
-console.log('Output:', result.output);
+if (result.status === TaskStatusCompleted) {
+  console.log('Output:', result.output);
+}
 ```
 
 ### With Setup Parameters
@@ -62,7 +66,7 @@ console.log('Output:', result.output);
 Setup parameters configure the app instance (e.g., model selection). Workers with matching setup are "warm" and skip setup:
 
 ```typescript
-const result = await client.run({
+const result = await client.tasks.run({
   app: 'my-app',
   setup: { model: 'schnell' },  // Setup parameters
   input: { prompt: 'hello' }
@@ -73,7 +77,7 @@ const result = await client.run({
 
 ```typescript
 // Get task info immediately without waiting
-const task = await client.run(
+const task = await client.tasks.run(
   { app: 'my-app', input: { prompt: 'hello' } },
   { wait: false }
 );
@@ -85,7 +89,7 @@ console.log('Status:', task.status);
 ### Real-time Status Updates
 
 ```typescript
-const result = await client.run(
+const result = await client.tasks.run(
   { app: 'my-app', input: { prompt: 'hello' } },
   {
     onUpdate: (update) => {
@@ -101,18 +105,18 @@ const result = await client.run(
 ```typescript
 async function processImages(images: string[]) {
   const results = [];
-  
+
   for (const image of images) {
-    const result = await client.run({
+    const result = await client.tasks.run({
       app: 'image-processor',
       input: { image }
     }, {
       onUpdate: (update) => console.log(`Processing: ${update.status}`)
     });
-    
+
     results.push(result);
   }
-  
+
   return results;
 }
 ```
@@ -121,13 +125,13 @@ async function processImages(images: string[]) {
 
 ```typescript
 // Upload from base64
-const file = await client.uploadFile('data:image/png;base64,...', {
+const file = await client.files.upload('data:image/png;base64,...', {
   filename: 'image.png',
   contentType: 'image/png'
 });
 
 // Use the uploaded file in a task
-const result = await client.run({
+const result = await client.tasks.run({
   app: 'image-app',
   input: { image: file.uri }
 });
@@ -136,18 +140,18 @@ const result = await client.run({
 ### Cancel a Task
 
 ```typescript
-const task = await client.run(
+const task = await client.tasks.run(
   { app: 'long-running-app', input: {} },
   { wait: false }
 );
 
 // Cancel if needed
-await client.cancel(task.id);
+await client.tasks.cancel(task.id);
 ```
 
 ## Agent Chat
 
-Chat with AI agents using `client.agent()`.
+Chat with AI agents using `client.agents.create()`.
 
 ### Using a Template Agent
 
@@ -159,7 +163,7 @@ import { inference } from '@inferencesh/sdk';
 const client = inference({ apiKey: 'your-api-key' });
 
 // Create agent from template
-const agent = client.agent('my-org/assistant@abc123');
+const agent = client.agents.create('my-org/assistant@abc123');
 
 // Send a message with streaming
 await agent.sendMessage('Hello!', {
@@ -188,7 +192,7 @@ import { inference, tool, string } from '@inferencesh/sdk';
 const client = inference({ apiKey: 'your-api-key' });
 
 // Create ad-hoc agent
-const agent = client.agent({
+const agent = client.agents.create({
   coreApp: 'infsh/claude-sonnet-4@abc123',  // LLM to use
   systemPrompt: 'You are a helpful assistant.',
   tools: [
@@ -235,7 +239,7 @@ Creates a new inference client.
 | `config.apiKey` | `string` | Yes | Your inference.sh API key |
 | `config.baseUrl` | `string` | No | Custom API URL (default: `https://api.inference.sh`) |
 
-### `client.run(params, options?)`
+### `client.tasks.run(params, options?)`
 
 Runs a task on inference.sh.
 
@@ -259,11 +263,15 @@ Runs a task on inference.sh.
 | `maxReconnects` | `number` | `5` | Max reconnection attempts |
 | `reconnectDelayMs` | `number` | `1000` | Delay between reconnects (ms) |
 
-### `client.cancel(taskId)`
+### `client.tasks.get(taskId)`
+
+Gets a task by ID.
+
+### `client.tasks.cancel(taskId)`
 
 Cancels a running task.
 
-### `client.uploadFile(data, options?)`
+### `client.files.upload(data, options?)`
 
 Uploads a file to inference.sh.
 
@@ -276,6 +284,24 @@ Uploads a file to inference.sh.
 | `options.contentType` | `string` | MIME type |
 | `options.public` | `boolean` | Make file publicly accessible |
 
+### `client.agents.create(templateOrConfig)`
+
+Creates an agent instance from a template or ad-hoc configuration.
+
+**Template mode:**
+```typescript
+const agent = client.agents.create('namespace/name@version');
+```
+
+**Ad-hoc mode:**
+```typescript
+const agent = client.agents.create({
+  coreApp: 'infsh/claude-sonnet-4@abc123',
+  systemPrompt: 'You are helpful.',
+  tools: [...]
+});
+```
+
 ## Task Status Constants
 
 ```typescript

package/dist/api/agents.d.ts

@@ -0,0 +1,144 @@
+import { HttpClient } from '../http/client';
+import { FilesAPI } from './files';
+import { ChatDTO, ChatMessageDTO, AgentConfig, AgentDTO, AgentVersionDTO, CreateAgentRequest, File, CursorListRequest, CursorListResponse } from '../types';
+/** Internal tool definition returned by getInternalTools */
+export interface InternalToolDefinition {
+    id: string;
+    name: string;
+    description: string;
+    tools: string[];
+    scope: string;
+}
+/** Options for creating an agent */
+export interface AgentOptions {
+    /** Optional name for the adhoc agent (used for deduplication and display) */
+    name?: string;
+}
+export interface SendMessageOptions {
+    /** File attachments - Blob (will be uploaded) or FileDTO (already uploaded, has uri) */
+    files?: (Blob | File)[];
+    /** Callback for message updates */
+    onMessage?: (message: ChatMessageDTO) => void;
+    /** Callback for chat updates */
+    onChat?: (chat: ChatDTO) => void;
+    /** Callback when a client tool needs execution */
+    onToolCall?: (invocation: {
+        id: string;
+        name: string;
+        args: Record<string, unknown>;
+    }) => void;
+}
+/**
+ * Agent for chat interactions
+ *
+ * Created via `client.agent()` - do not instantiate directly.
+ */
+export declare class Agent {
+    private readonly http;
+    private readonly files;
+    private readonly config;
+    private readonly agentName;
+    private chatId;
+    private stream;
+    private dispatchedToolCalls;
+    /** @internal */
+    constructor(http: HttpClient, files: FilesAPI, config: string | AgentConfig, options?: AgentOptions);
+    /** Get current chat ID */
+    get currentChatId(): string | null;
+    /** Send a message to the agent */
+    sendMessage(text: string, options?: SendMessageOptions): Promise<{
+        userMessage: ChatMessageDTO;
+        assistantMessage: ChatMessageDTO;
+    }>;
+    /** Get chat by ID */
+    getChat(chatId?: string): Promise<ChatDTO | null>;
+    /** Stop the current chat generation */
+    stopChat(): Promise<void>;
+    /**
+     * Submit a tool result
+     */
+    submitToolResult(toolInvocationId: string, resultOrAction: string | {
+        action: {
+            type: string;
+            payload?: Record<string, unknown>;
+        };
+        form_data?: Record<string, unknown>;
+    }): Promise<void>;
+    /** Stop streaming and cleanup */
+    disconnect(): void;
+    /** Reset the agent (start fresh chat) */
+    reset(): void;
+    /**
+     * Start streaming for the current chat.
+     */
+    startStreaming(options?: Omit<SendMessageOptions, 'files'>): void;
+    /** Stream events until chat becomes idle */
+    private streamUntilIdle;
+}
+/**
+ * Agents API
+ */
+export declare class AgentsAPI {
+    private readonly http;
+    private readonly files;
+    constructor(http: HttpClient, files: FilesAPI);
+    /**
+     * List agent templates with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<AgentDTO>>;
+    /**
+     * Get an agent template by ID
+     */
+    get(agentId: string): Promise<AgentDTO>;
+    /**
+     * Create a new agent template or create a new version of an existing agent
+     */
+    createAgent(data: CreateAgentRequest): Promise<AgentDTO>;
+    /**
+     * Update an agent template
+     */
+    update(agentId: string, data: Partial<AgentDTO>): Promise<AgentDTO>;
+    /**
+     * Delete an agent template
+     */
+    delete(agentId: string): Promise<void>;
+    /**
+     * Duplicate an agent template
+     */
+    duplicate(agentId: string): Promise<AgentDTO>;
+    /**
+     * List agent template versions
+     */
+    listVersions(agentId: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<AgentVersionDTO>>;
+    /**
+     * Transfer agent ownership to another team
+     */
+    transferOwnership(agentId: string, newTeamId: string): Promise<AgentDTO>;
+    /**
+     * Update agent visibility
+     */
+    updateVisibility(agentId: string, visibility: string): Promise<AgentDTO>;
+    /**
+     * Get a specific agent version
+     */
+    getVersion(agentId: string, versionId: string): Promise<AgentVersionDTO>;
+    /**
+     * Get internal tools for the agent
+     */
+    getInternalTools(): Promise<InternalToolDefinition[]>;
+    /**
+     * Create an agent instance for chat interactions
+     */
+    create(config: string | AgentConfig, options?: AgentOptions): Agent;
+    /**
+     * Submit a tool result
+     */
+    submitToolResult(toolInvocationId: string, resultOrAction: string | {
+        action: {
+            type: string;
+            payload?: Record<string, unknown>;
+        };
+        form_data?: Record<string, unknown>;
+    }): Promise<void>;
+}
+export declare function createAgentsAPI(http: HttpClient, files: FilesAPI): AgentsAPI;

package/dist/api/agents.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentsAPI = exports.Agent = void 0;
+exports.createAgentsAPI = createAgentsAPI;
+const stream_1 = require("../http/stream");
+const types_1 = require("../types");
+/**
+ * Agent for chat interactions
+ *
+ * Created via `client.agent()` - do not instantiate directly.
+ */
+class Agent {
+    /** @internal */
+    constructor(http, files, config, options) {
+        this.chatId = null;
+        this.stream = null;
+        this.dispatchedToolCalls = new Set();
+        this.http = http;
+        this.files = files;
+        this.config = config;
+        this.agentName = options?.name;
+    }
+    /** Get current chat ID */
+    get currentChatId() {
+        return this.chatId;
+    }
+    /** Send a message to the agent */
+    async sendMessage(text, options = {}) {
+        const isTemplate = typeof this.config === 'string';
+        const hasCallbacks = !!(options.onMessage || options.onChat || options.onToolCall);
+        // Process files - either already uploaded (FileDTO with uri) or needs upload (Blob)
+        let imageUris;
+        let fileUris;
+        if (options.files && options.files.length > 0) {
+            const toUpload = [];
+            const alreadyUploaded = [];
+            for (const file of options.files) {
+                if ('uri' in file && typeof file.uri === 'string') {
+                    alreadyUploaded.push(file);
+                }
+                else {
+                    toUpload.push(file);
+                }
+            }
+            const uploadedFiles = toUpload.length > 0 ? await Promise.all(toUpload.map((blob) => this.files.upload(blob))) : [];
+            const allFiles = [...alreadyUploaded, ...uploadedFiles];
+            const images = allFiles.filter((f) => f.content_type?.startsWith('image/'));
+            const others = allFiles.filter((f) => !f.content_type?.startsWith('image/'));
+            if (images.length > 0)
+                imageUris = images.map((f) => f.uri);
+            if (others.length > 0)
+                fileUris = others.map((f) => f.uri);
+        }
+        const body = isTemplate
+            ? {
+                chat_id: this.chatId,
+                agent: this.config,
+                input: { text, images: imageUris, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
+            }
+            : {
+                chat_id: this.chatId,
+                agent_config: this.config,
+                agent_name: this.agentName,
+                input: { text, images: imageUris, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
+            };
+        // For existing chats with callbacks: Start streaming BEFORE POST so we don't miss updates
+        let streamPromise = null;
+        if (this.chatId && hasCallbacks) {
+            streamPromise = this.streamUntilIdle(options);
+        }
+        // Make the POST request
+        const response = await this.http.request('post', '/agents/run', { data: body });
+        // For new chats: Set chatId and start streaming immediately after POST
+        const isNewChat = !this.chatId && response.assistant_message.chat_id;
+        if (isNewChat) {
+            this.chatId = response.assistant_message.chat_id;
+            if (hasCallbacks) {
+                streamPromise = this.streamUntilIdle(options);
+            }
+        }
+        // Wait for streaming to complete
+        if (streamPromise) {
+            await streamPromise;
+        }
+        return { userMessage: response.user_message, assistantMessage: response.assistant_message };
+    }
+    /** Get chat by ID */
+    async getChat(chatId) {
+        const id = chatId || this.chatId;
+        if (!id)
+            return null;
+        return this.http.request('get', `/chats/${id}`);
+    }
+    /** Stop the current chat generation */
+    async stopChat() {
+        if (!this.chatId)
+            return;
+        await this.http.request('post', `/chats/${this.chatId}/stop`);
+    }
+    /**
+     * Submit a tool result
+     */
+    async submitToolResult(toolInvocationId, resultOrAction) {
+        const result = typeof resultOrAction === 'string' ? resultOrAction : JSON.stringify(resultOrAction);
+        await this.http.request('post', `/tools/${toolInvocationId}`, { data: { result } });
+    }
+    /** Stop streaming and cleanup */
+    disconnect() {
+        this.stream?.stop();
+        this.stream = null;
+    }
+    /** Reset the agent (start fresh chat) */
+    reset() {
+        this.disconnect();
+        this.chatId = null;
+        this.dispatchedToolCalls.clear();
+    }
+    /**
+     * Start streaming for the current chat.
+     */
+    startStreaming(options = {}) {
+        if (!this.chatId)
+            return;
+        this.streamUntilIdle(options);
+    }
+    /** Stream events until chat becomes idle */
+    streamUntilIdle(options) {
+        if (!this.chatId)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this.stream?.stop();
+            this.stream = new stream_1.StreamManager({
+                createEventSource: async () => this.http.createEventSource(`/chats/${this.chatId}/stream`),
+                autoReconnect: true,
+            });
+            this.stream.addEventListener('chats', (chat) => {
+                options.onChat?.(chat);
+                if (chat.status === 'idle') {
+                    resolve();
+                }
+            });
+            this.stream.addEventListener('chat_messages', (message) => {
+                options.onMessage?.(message);
+                if (message.tool_invocations && options.onToolCall) {
+                    for (const inv of message.tool_invocations) {
+                        if (this.dispatchedToolCalls.has(inv.id))
+                            continue;
+                        if (inv.type === types_1.ToolTypeClient && inv.status === types_1.ToolInvocationStatusAwaitingInput) {
+                            this.dispatchedToolCalls.add(inv.id);
+                            options.onToolCall({
+                                id: inv.id,
+                                name: inv.function?.name || '',
+                                args: inv.function?.arguments || {},
+                            });
+                        }
+                    }
+                }
+            });
+            this.stream.connect();
+        });
+    }
+}
+exports.Agent = Agent;
+/**
+ * Agents API
+ */
+class AgentsAPI {
+    constructor(http, files) {
+        this.http = http;
+        this.files = files;
+    }
+    // ==========================================================================
+    // Agent Template CRUD (stored agent configurations)
+    // ==========================================================================
+    /**
+     * List agent templates with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/agents/list', { data: params });
+    }
+    /**
+     * Get an agent template by ID
+     */
+    async get(agentId) {
+        return this.http.request('get', `/agents/${agentId}`);
+    }
+    /**
+     * Create a new agent template or create a new version of an existing agent
+     */
+    async createAgent(data) {
+        return this.http.request('post', '/agents', { data });
+    }
+    /**
+     * Update an agent template
+     */
+    async update(agentId, data) {
+        return this.http.request('put', `/agents/${agentId}`, { data });
+    }
+    /**
+     * Delete an agent template
+     */
+    async delete(agentId) {
+        return this.http.request('delete', `/agents/${agentId}`);
+    }
+    /**
+     * Duplicate an agent template
+     */
+    async duplicate(agentId) {
+        return this.http.request('post', `/agents/${agentId}/duplicate`);
+    }
+    /**
+     * List agent template versions
+     */
+    async listVersions(agentId, params) {
+        return this.http.request('post', `/agents/${agentId}/versions/list`, { data: params });
+    }
+    /**
+     * Transfer agent ownership to another team
+     */
+    async transferOwnership(agentId, newTeamId) {
+        return this.http.request('post', `/agents/${agentId}/transfer`, { data: { team_id: newTeamId } });
+    }
+    /**
+     * Update agent visibility
+     */
+    async updateVisibility(agentId, visibility) {
+        return this.http.request('put', `/agents/${agentId}/visibility`, { data: { visibility } });
+    }
+    /**
+     * Get a specific agent version
+     */
+    async getVersion(agentId, versionId) {
+        return this.http.request('get', `/agents/${agentId}/versions/${versionId}`);
+    }
+    /**
+     * Get internal tools for the agent
+     */
+    async getInternalTools() {
+        return this.http.request('get', '/agents/internal-tools');
+    }
+    // ==========================================================================
+    // Agent Runtime (chat interactions)
+    // ==========================================================================
+    /**
+     * Create an agent instance for chat interactions
+     */
+    create(config, options) {
+        return new Agent(this.http, this.files, config, options);
+    }
+    /**
+     * Submit a tool result
+     */
+    async submitToolResult(toolInvocationId, resultOrAction) {
+        const result = typeof resultOrAction === 'string' ? resultOrAction : JSON.stringify(resultOrAction);
+        await this.http.request('post', `/tools/${toolInvocationId}`, { data: { result } });
+    }
+}
+exports.AgentsAPI = AgentsAPI;
+function createAgentsAPI(http, files) {
+    return new AgentsAPI(http, files);
+}

package/dist/api/apps.d.ts

@@ -0,0 +1,72 @@
+import { HttpClient } from '../http/client';
+import { AppDTO as App, AppVersionDTO, CursorListRequest, CursorListResponse } from '../types';
+interface LicenseRecord {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    deleted_at?: string;
+    user_id: string;
+    app_id: string;
+    license: string;
+}
+/**
+ * Apps API
+ */
+export declare class AppsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List apps with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<App>>;
+    /**
+     * Get an app by ID
+     */
+    get(appId: string): Promise<App>;
+    /**
+     * Get an app by version ID
+     */
+    getByVersionId(appId: string, versionId: string): Promise<App>;
+    /**
+     * Create a new app
+     */
+    create(data: Partial<App>): Promise<App>;
+    /**
+     * Update an app
+     */
+    update(appId: string, data: Partial<App>): Promise<App>;
+    /**
+     * Delete an app
+     */
+    delete(appId: string): Promise<void>;
+    /**
+     * Duplicate an app
+     */
+    duplicate(appId: string): Promise<App>;
+    /**
+     * List app versions
+     */
+    listVersions(appId: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<AppVersionDTO>>;
+    /**
+     * Transfer app ownership to another team
+     */
+    transferOwnership(appId: string, newTeamId: string): Promise<App>;
+    /**
+     * Update app visibility
+     */
+    updateVisibility(appId: string, visibility: string): Promise<App>;
+    /**
+     * Get an app by namespace and name (e.g., "inference/claude-haiku")
+     */
+    getByName(name: string): Promise<App>;
+    /**
+     * Get app license record
+     */
+    getLicense(appId: string): Promise<LicenseRecord>;
+    /**
+     * Save app license
+     */
+    saveLicense(appId: string, license: string): Promise<LicenseRecord>;
+}
+export declare function createAppsAPI(http: HttpClient): AppsAPI;
+export {};