@inferencesh/sdk 0.4.26 → 0.5.1

package/README.md

@@ -1,11 +1,13 @@
-# @inferencesh/sdk
+# @inferencesh/sdk — ai inference api for javascript & typescript
 
 [![npm version](https://img.shields.io/npm/v/@inferencesh/sdk.svg)](https://www.npmjs.com/package/@inferencesh/sdk)
 [![npm downloads](https://img.shields.io/npm/dm/@inferencesh/sdk.svg)](https://www.npmjs.com/package/@inferencesh/sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
 
-Official JavaScript/TypeScript SDK for [inference.sh](https://inference.sh) — Run AI models with a simple API.
+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 150+ models including flux, stable diffusion, llms (claude, gpt, gemini), video generation (veo, seedance), and more.
 
 ## Installation
 
@@ -149,6 +151,53 @@ const task = await client.tasks.run(
 await client.tasks.cancel(task.id);
 ```
 
+### Sessions (Stateful Execution)
+
+Sessions allow you to maintain state across multiple task invocations. The worker stays warm between calls, preserving loaded models and in-memory state.
+
+```typescript
+// Start a new session
+const result = await client.tasks.run({
+  app: 'my-stateful-app',
+  input: { prompt: 'hello' },
+  session: 'new'
+});
+
+const sessionId = result.session_id;
+console.log('Session ID:', sessionId);
+
+// Continue the session with another call
+const result2 = await client.tasks.run({
+  app: 'my-stateful-app',
+  input: { prompt: 'remember what I said?' },
+  session: sessionId
+});
+```
+
+#### Custom Session Timeout
+
+By default, sessions expire after 60 seconds of inactivity. You can customize this with `session_timeout` (1-3600 seconds):
+
+```typescript
+// Create a session with 5-minute idle timeout
+const result = await client.tasks.run({
+  app: 'my-stateful-app',
+  input: { prompt: 'hello' },
+  session: 'new',
+  session_timeout: 300  // 5 minutes
+});
+
+// Session stays alive for 5 minutes after each call
+```
+
+**Notes:**
+- `session_timeout` is only valid when `session: 'new'`
+- Minimum timeout: 1 second
+- Maximum timeout: 3600 seconds (1 hour)
+- Each successful call resets the idle timer
+
+For complete session documentation including error handling, best practices, and advanced patterns, see the [Sessions Developer Guide](https://inference.sh/docs/extend/sessions).
+
 ## Agent Chat
 
 Chat with AI agents using `client.agents.create()`.
@@ -252,6 +301,8 @@ Runs a task on inference.sh.
 | `params.setup` | `object` | No | Setup parameters (affects worker warmth/scheduling) |
 | `params.infra` | `string` | No | Infrastructure: `'cloud'` or `'private'` |
 | `params.variant` | `string` | No | App variant to use |
+| `params.session` | `string` | No | Session ID or `'new'` to start a new session |
+| `params.session_timeout` | `number` | No | Session timeout in seconds (1-3600, only with `session: 'new'`) |
 
 **Options:**
 
@@ -331,6 +382,14 @@ import type { Task, ApiTaskRequest, RunOptions } from '@inferencesh/sdk';
 - Node.js 18.0.0 or higher
 - Modern browsers with `fetch` support
 
-## License
+## resources
+
+- [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 150+ ai models
+- [discord](https://discord.gg/RM77SWSbyT) — community support
+- [github](https://github.com/inference-sh) — open source projects
+
+## license
 
 MIT © [inference.sh](https://inference.sh)

package/dist/agent/hooks.d.ts

@@ -3,7 +3,8 @@
  *
  * React hooks for accessing chat state and actions.
  */
-import type { AgentChatState, AgentChatActions, ChatMessageDTO, AgentClient } from './types';
+import type { AgentChatState, AgentChatActions, AgentClient } from './types';
+import type { ChatMessageDTO } from '../types';
 /**
  * Hook to access chat state
  *

package/dist/agent/index.d.ts

@@ -45,5 +45,5 @@
 export { AgentChatProvider } from './provider';
 export { useAgentChat, useAgentActions, useAgentClient, useAgentChatContext, useMessage, } from './hooks';
 export { AgentChatContext, type AgentChatContextValue } from './context';
-export type { AgentClient, UploadedFile, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, ChatMessageDTO, ChatDTO, ToolInvocationDTO, ChatMessageContent, ChatMessageRole, } from './types';
+export type { AgentClient, UploadedFile, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
 export { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';

package/dist/agent/types.d.ts

@@ -4,7 +4,7 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { ChatDTO, ChatMessageDTO, ToolInvocationDTO, ChatMessageContent, ChatMessageRole, TaskStatus, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig } from '../types';
+import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamManager } from '../http/stream';
 /**
@@ -26,10 +26,29 @@ export interface AgentClient {
         upload: (data: string | Blob | globalThis.File) => Promise<UploadedFile>;
     };
 }
-export type { ChatMessageDTO, ChatDTO, ToolInvocationDTO, ChatMessageContent, ChatMessageRole, TaskStatus, };
 /**
  * Configuration for an ad-hoc agent - extends generated AgentConfig
  * Adds support for ClientTool (browser-side tool handlers)
+ *
+ * @example
+ * ```ts
+ * const config: AdHocAgentConfig = {
+ *   core_app: { ref: 'openrouter/claude-sonnet-4@abc123' },
+ *   system_prompt: 'You are a helpful assistant.',
+ *   skills: [
+ *     {
+ *       name: 'code-review',
+ *       description: 'Guidelines for reviewing code',
+ *       content: '# Code Review\n\nWhen reviewing code...'
+ *     },
+ *     {
+ *       name: 'api-docs',
+ *       description: 'API documentation',
+ *       url: 'https://example.com/skills/api-docs.md'
+ *     }
+ *   ]
+ * }
+ * ```
  */
 export type AdHocAgentConfig = Omit<Partial<GeneratedAgentConfig>, 'tools' | 'core_app'> & {
     /** Core LLM app configuration (required for ad-hoc agents) */

package/dist/api/apps.d.ts

@@ -1,14 +1,5 @@
 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;
-}
+import { AppDTO as App, AppVersionDTO, CursorListRequest, CursorListResponse, LicenseRecord } from '../types';
 /**
  * Apps API
  */
@@ -69,4 +60,3 @@ export declare class AppsAPI {
     saveLicense(appId: string, license: string): Promise<LicenseRecord>;
 }
 export declare function createAppsAPI(http: HttpClient): AppsAPI;
-export {};

package/dist/api/files.js

@@ -111,11 +111,22 @@ export class FilesAPI {
             return processed;
         }
         // Handle base64 strings or data URIs
-        if (typeof input === 'string' &&
-            (input.startsWith('data:') ||
-                /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$/.test(input))) {
-            const file = await this.upload(input);
-            return file.uri;
+        // Only treat as base64 if it's a data URI OR if it looks like base64 AND is reasonably long
+        // Short strings like "key1" or "test" shouldn't be treated as base64
+        if (typeof input === 'string') {
+            if (input.startsWith('data:')) {
+                // Data URIs are always treated as files
+                const file = await this.upload(input);
+                return file.uri;
+            }
+            // For raw base64, require minimum length (64 chars ~= 48 bytes of data)
+            // and must match base64 pattern with proper padding
+            if (input.length >= 64 &&
+                /^[A-Za-z0-9+/]+={0,2}$/.test(input) &&
+                input.length % 4 === 0) {
+                const file = await this.upload(input);
+                return file.uri;
+            }
         }
         return input;
     }

package/dist/api/index.d.ts

@@ -1,3 +1,4 @@
 export { TasksAPI, createTasksAPI, RunOptions } from './tasks';
 export { FilesAPI, createFilesAPI, UploadFileOptions } from './files';
 export { AgentsAPI, createAgentsAPI, Agent, AgentOptions, SendMessageOptions } from './agents';
+export { SessionsAPI, createSessionsAPI } from './sessions';

package/dist/api/index.js

@@ -1,3 +1,4 @@
 export { TasksAPI, createTasksAPI } from './tasks';
 export { FilesAPI, createFilesAPI } from './files';
 export { AgentsAPI, createAgentsAPI, Agent } from './agents';
+export { SessionsAPI, createSessionsAPI } from './sessions';

package/dist/api/sessions.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Sessions API - namespaced session operations.
+ */
+import { HttpClient } from '../http/client';
+import { AppSession } from '../types';
+/**
+ * Sessions API for managing stateful worker leases.
+ *
+ * @example
+ * ```typescript
+ * const client = new Inference({ apiKey: '...' });
+ *
+ * // Get session info
+ * const info = await client.sessions.get('sess_abc123');
+ * console.log(info.status);
+ *
+ * // List sessions
+ * const sessions = await client.sessions.list();
+ *
+ * // Keep session alive
+ * await client.sessions.keepalive('sess_abc123');
+ *
+ * // End session
+ * await client.sessions.end('sess_abc123');
+ * ```
+ */
+export declare class SessionsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Get information about a session.
+     *
+     * @param sessionId - The session ID
+     * @returns Session information
+     * @throws SessionNotFoundError if session doesn't exist
+     */
+    get(sessionId: string): Promise<AppSession>;
+    /**
+     * List all sessions for the current user/team.
+     *
+     * @returns List of session information
+     */
+    list(): Promise<AppSession[]>;
+    /**
+     * Extend session expiration time.
+     *
+     * Each call resets the expiration timer (sliding window).
+     *
+     * @param sessionId - The session ID
+     * @returns Updated session information
+     * @throws SessionNotFoundError if session doesn't exist
+     * @throws SessionExpiredError if session has expired
+     * @throws SessionEndedError if session was ended
+     */
+    keepalive(sessionId: string): Promise<AppSession>;
+    /**
+     * End a session and release the worker.
+     *
+     * @param sessionId - The session ID
+     * @throws SessionNotFoundError if session doesn't exist
+     */
+    end(sessionId: string): Promise<void>;
+}
+/**
+ * Create a new SessionsAPI instance.
+ */
+export declare function createSessionsAPI(http: HttpClient): SessionsAPI;

package/dist/api/sessions.js

@@ -0,0 +1,77 @@
+/**
+ * Sessions API - namespaced session operations.
+ */
+/**
+ * Sessions API for managing stateful worker leases.
+ *
+ * @example
+ * ```typescript
+ * const client = new Inference({ apiKey: '...' });
+ *
+ * // Get session info
+ * const info = await client.sessions.get('sess_abc123');
+ * console.log(info.status);
+ *
+ * // List sessions
+ * const sessions = await client.sessions.list();
+ *
+ * // Keep session alive
+ * await client.sessions.keepalive('sess_abc123');
+ *
+ * // End session
+ * await client.sessions.end('sess_abc123');
+ * ```
+ */
+export class SessionsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Get information about a session.
+     *
+     * @param sessionId - The session ID
+     * @returns Session information
+     * @throws SessionNotFoundError if session doesn't exist
+     */
+    async get(sessionId) {
+        return this.http.request('get', `/sessions/${sessionId}`);
+    }
+    /**
+     * List all sessions for the current user/team.
+     *
+     * @returns List of session information
+     */
+    async list() {
+        const data = await this.http.request('get', '/sessions');
+        return data || [];
+    }
+    /**
+     * Extend session expiration time.
+     *
+     * Each call resets the expiration timer (sliding window).
+     *
+     * @param sessionId - The session ID
+     * @returns Updated session information
+     * @throws SessionNotFoundError if session doesn't exist
+     * @throws SessionExpiredError if session has expired
+     * @throws SessionEndedError if session was ended
+     */
+    async keepalive(sessionId) {
+        return this.http.request('post', `/sessions/${sessionId}/keepalive`);
+    }
+    /**
+     * End a session and release the worker.
+     *
+     * @param sessionId - The session ID
+     * @throws SessionNotFoundError if session doesn't exist
+     */
+    async end(sessionId) {
+        await this.http.request('delete', `/sessions/${sessionId}`);
+    }
+}
+/**
+ * Create a new SessionsAPI instance.
+ */
+export function createSessionsAPI(http) {
+    return new SessionsAPI(http);
+}

package/dist/api/tasks.js

@@ -1,5 +1,6 @@
 import { StreamManager } from '../http/stream';
 import { TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, } from '../types';
+//TODO: This is ugly...
 function stripTask(task) {
     return {
         ...task,
@@ -10,6 +11,7 @@ function stripTask(task) {
         output: task.output,
         logs: task.logs,
         status: task.status,
+        session_id: task.session_id,
     };
 }
 /**
@@ -77,6 +79,8 @@ export class TasksAPI {
             return stripTask(task);
         }
         // Wait for completion with optional updates
+        // Accumulate state across partial updates to preserve fields like session_id
+        let accumulatedTask = { ...task };
         return new Promise((resolve, reject) => {
             const streamManager = new StreamManager({
                 createEventSource: async () => this.http.createEventSource(`/tasks/${task.id}/stream`),
@@ -84,7 +88,9 @@ export class TasksAPI {
                 maxReconnects,
                 reconnectDelayMs,
                 onData: (data) => {
-                    const stripped = stripTask(data);
+                    // Merge new data, preserving existing fields if not in update
+                    accumulatedTask = { ...accumulatedTask, ...data };
+                    const stripped = stripTask(accumulatedTask);
                     onUpdate?.(stripped);
                     if (data.status === TaskStatusCompleted) {
                         streamManager.stop();
@@ -100,7 +106,9 @@ export class TasksAPI {
                     }
                 },
                 onPartialData: (data, fields) => {
-                    const stripped = stripTask(data);
+                    // Merge partial update, preserving fields not in this update
+                    accumulatedTask = { ...accumulatedTask, ...data };
+                    const stripped = stripTask(accumulatedTask);
                     onPartialUpdate?.(stripped, fields);
                     if (data.status === TaskStatusCompleted) {
                         streamManager.stop();

package/dist/http/client.js

@@ -135,6 +135,10 @@ export class HttpClient {
             }
             throw new InferenceError(response.status, errorDetail || 'Request failed', responseText);
         }
+        // Handle 204 No Content (e.g., DELETE requests)
+        if (response.status === 204) {
+            return undefined;
+        }
         const apiResponse = data;
         if (!apiResponse?.success) {
             let errorMessage = apiResponse?.error?.message;

package/dist/http/errors.d.ts

@@ -48,3 +48,85 @@ export declare class RequirementsNotMetException extends Error {
         errors?: RequirementError[];
     }, statusCode?: number): RequirementsNotMetException;
 }
+/**
+ * Base class for session-related errors.
+ */
+export declare class SessionError extends InferenceError {
+    readonly sessionId: string;
+    constructor(sessionId: string, statusCode: number, message: string, responseBody?: string);
+}
+/**
+ * Error thrown when a session doesn't exist (404 SESSION_NOT_FOUND).
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.sessions.get('sess_invalid');
+ * } catch (e) {
+ *   if (e instanceof SessionNotFoundError) {
+ *     console.log('Session not found');
+ *   }
+ * }
+ * ```
+ */
+export declare class SessionNotFoundError extends SessionError {
+    constructor(sessionId: string, responseBody?: string);
+}
+/**
+ * Error thrown when a session has expired (410 SESSION_EXPIRED).
+ *
+ * Sessions expire after an idle timeout (default: 5 minutes).
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await client.run({ ..., session: sessionId });
+ * } catch (e) {
+ *   if (e instanceof SessionExpiredError) {
+ *     // Create new session
+ *     const result = await client.run({ ..., session: 'new' });
+ *   }
+ * }
+ * ```
+ */
+export declare class SessionExpiredError extends SessionError {
+    constructor(sessionId: string, responseBody?: string);
+}
+/**
+ * Error thrown when a session was explicitly ended (410 SESSION_ENDED).
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await client.run({ ..., session: sessionId });
+ * } catch (e) {
+ *   if (e instanceof SessionEndedError) {
+ *     // Create new session
+ *     const result = await client.run({ ..., session: 'new' });
+ *   }
+ * }
+ * ```
+ */
+export declare class SessionEndedError extends SessionError {
+    constructor(sessionId: string, responseBody?: string);
+}
+/**
+ * Error thrown when the worker assigned to a session is lost.
+ *
+ * This can happen if the worker crashes or is terminated unexpectedly.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await client.run({ ..., session: sessionId });
+ * } catch (e) {
+ *   if (e instanceof WorkerLostError) {
+ *     // Worker crashed, create new session
+ *     const result = await client.run({ ..., session: 'new' });
+ *   }
+ * }
+ * ```
+ */
+export declare class WorkerLostError extends SessionError {
+    constructor(sessionId: string, responseBody?: string);
+}

package/dist/http/errors.js

@@ -54,3 +54,101 @@ export class RequirementsNotMetException extends Error {
         return new RequirementsNotMetException(data.errors || [], statusCode);
     }
 }
+// Session-specific errors
+/**
+ * Base class for session-related errors.
+ */
+export class SessionError extends InferenceError {
+    constructor(sessionId, statusCode, message, responseBody) {
+        super(statusCode, message, responseBody);
+        this.name = 'SessionError';
+        this.sessionId = sessionId;
+    }
+}
+/**
+ * Error thrown when a session doesn't exist (404 SESSION_NOT_FOUND).
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await client.sessions.get('sess_invalid');
+ * } catch (e) {
+ *   if (e instanceof SessionNotFoundError) {
+ *     console.log('Session not found');
+ *   }
+ * }
+ * ```
+ */
+export class SessionNotFoundError extends SessionError {
+    constructor(sessionId, responseBody) {
+        super(sessionId, 404, `Session not found: ${sessionId}`, responseBody);
+        this.name = 'SessionNotFoundError';
+    }
+}
+/**
+ * Error thrown when a session has expired (410 SESSION_EXPIRED).
+ *
+ * Sessions expire after an idle timeout (default: 5 minutes).
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await client.run({ ..., session: sessionId });
+ * } catch (e) {
+ *   if (e instanceof SessionExpiredError) {
+ *     // Create new session
+ *     const result = await client.run({ ..., session: 'new' });
+ *   }
+ * }
+ * ```
+ */
+export class SessionExpiredError extends SessionError {
+    constructor(sessionId, responseBody) {
+        super(sessionId, 410, `Session expired: ${sessionId}`, responseBody);
+        this.name = 'SessionExpiredError';
+    }
+}
+/**
+ * Error thrown when a session was explicitly ended (410 SESSION_ENDED).
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await client.run({ ..., session: sessionId });
+ * } catch (e) {
+ *   if (e instanceof SessionEndedError) {
+ *     // Create new session
+ *     const result = await client.run({ ..., session: 'new' });
+ *   }
+ * }
+ * ```
+ */
+export class SessionEndedError extends SessionError {
+    constructor(sessionId, responseBody) {
+        super(sessionId, 410, `Session ended: ${sessionId}`, responseBody);
+        this.name = 'SessionEndedError';
+    }
+}
+/**
+ * Error thrown when the worker assigned to a session is lost.
+ *
+ * This can happen if the worker crashes or is terminated unexpectedly.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await client.run({ ..., session: sessionId });
+ * } catch (e) {
+ *   if (e instanceof WorkerLostError) {
+ *     // Worker crashed, create new session
+ *     const result = await client.run({ ..., session: 'new' });
+ *   }
+ * }
+ * ```
+ */
+export class WorkerLostError extends SessionError {
+    constructor(sessionId, responseBody) {
+        super(sessionId, 500, `Worker lost for session: ${sessionId}`, responseBody);
+        this.name = 'WorkerLostError';
+    }
+}

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 export { HttpClient, HttpClientConfig, ErrorHandler, createHttpClient } from './http/client';
 export { StreamManager, StreamManagerOptions, PartialDataWrapper } from './http/stream';
-export { InferenceError, RequirementsNotMetException } from './http/errors';
+export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, } from './http/errors';
 export { TasksAPI, RunOptions } from './api/tasks';
 export { FilesAPI, UploadFileOptions } from './api/files';
 export { AgentsAPI, Agent, AgentOptions, SendMessageOptions } from './api/agents';
+export { SessionsAPI } from './api/sessions';
 export { AppsAPI } from './api/apps';
 export { ChatsAPI } from './api/chats';
 export { FlowsAPI } from './api/flows';
@@ -17,6 +18,7 @@ import { HttpClient, HttpClientConfig } from './http/client';
 import { TasksAPI, RunOptions } from './api/tasks';
 import { FilesAPI, UploadFileOptions } from './api/files';
 import { AgentsAPI, Agent, AgentOptions } from './api/agents';
+import { SessionsAPI } from './api/sessions';
 import { AppsAPI } from './api/apps';
 import { ChatsAPI } from './api/chats';
 import { FlowsAPI } from './api/flows';
@@ -48,6 +50,7 @@ export declare class Inference {
     readonly tasks: TasksAPI;
     readonly files: FilesAPI;
     readonly agents: AgentsAPI;
+    readonly sessions: SessionsAPI;
     readonly apps: AppsAPI;
     readonly chats: ChatsAPI;
     readonly flows: FlowsAPI;

package/dist/index.js

@@ -1,11 +1,12 @@
 // HTTP utilities
 export { HttpClient, createHttpClient } from './http/client';
 export { StreamManager } from './http/stream';
-export { InferenceError, RequirementsNotMetException } from './http/errors';
+export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, } from './http/errors';
 // API modules
 export { TasksAPI } from './api/tasks';
 export { FilesAPI } from './api/files';
 export { AgentsAPI, Agent } from './api/agents';
+export { SessionsAPI } from './api/sessions';
 export { AppsAPI } from './api/apps';
 export { ChatsAPI } from './api/chats';
 export { FlowsAPI } from './api/flows';
@@ -22,6 +23,7 @@ import { HttpClient } from './http/client';
 import { TasksAPI } from './api/tasks';
 import { FilesAPI } from './api/files';
 import { AgentsAPI } from './api/agents';
+import { SessionsAPI } from './api/sessions';
 import { AppsAPI } from './api/apps';
 import { ChatsAPI } from './api/chats';
 import { FlowsAPI } from './api/flows';
@@ -51,6 +53,7 @@ export class Inference {
         this.files = new FilesAPI(this.http);
         this.tasks = new TasksAPI(this.http);
         this.agents = new AgentsAPI(this.http, this.files);
+        this.sessions = new SessionsAPI(this.http);
         this.apps = new AppsAPI(this.http);
         this.chats = new ChatsAPI(this.http);
         this.flows = new FlowsAPI(this.http);

package/dist/sessions.integration.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sessions integration tests for @inferencesh/sdk
+ *
+ * These tests hit the real API and require INFERENCE_API_KEY to be set.
+ * Run with: npm run test:integration
+ *
+ * Prerequisites:
+ *   - API and scheduler must be running
+ *   - Test app deployed: infsh/session-test
+ *
+ * @jest-environment node
+ */
+export {};