@inferencesh/sdk 0.5.12 → 0.5.14

package/dist/agent/actions.js

@@ -77,7 +77,7 @@ export function createActions(ctx) {
             existingManager.stop();
         }
         setStreamManager(undefined);
-        dispatch({ type: 'SET_STATUS', payload: 'connecting' });
+        dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'connecting' });
         callbacks.onStatusChange?.('connecting');
         try {
             // Fetch initial chat
@@ -88,8 +88,7 @@ export function createActions(ctx) {
         }
         catch (error) {
             console.error('[AgentSDK] Failed to fetch chat:', error);
-            dispatch({ type: 'SET_STATUS', payload: 'idle' });
-            dispatch({ type: 'SET_IS_GENERATING', payload: false });
+            dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
             callbacks.onStatusChange?.('idle');
             return;
         }
@@ -108,7 +107,7 @@ export function createActions(ctx) {
                 callbacks.onError?.(error);
             },
             onStart: () => {
-                dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'streaming' });
                 callbacks.onStatusChange?.('streaming');
             },
             onEnd: () => {
@@ -117,8 +116,7 @@ export function createActions(ctx) {
                 // so getStreamManager() will be undefined and we skip the duplicate dispatch.
                 if (getStreamManager()) {
                     setStreamManager(undefined);
-                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
-                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
                     callbacks.onStatusChange?.('idle');
                 }
             },
@@ -162,14 +160,13 @@ export function createActions(ctx) {
                 }
             },
             onStart: () => {
-                dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'streaming' });
                 callbacks.onStatusChange?.('streaming');
             },
             onStop: () => {
                 if (getStreamManager()) {
                     setStreamManager(undefined);
-                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
-                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
                     callbacks.onStatusChange?.('idle');
                 }
             },
@@ -188,8 +185,7 @@ export function createActions(ctx) {
         if (manager) {
             manager.stop();
         }
-        dispatch({ type: 'SET_STATUS', payload: 'idle' });
-        dispatch({ type: 'SET_IS_GENERATING', payload: false });
+        dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
         callbacks.onStatusChange?.('idle');
     };
     // =========================================================================
@@ -207,7 +203,7 @@ export function createActions(ctx) {
             if (!trimmedText)
                 return;
             // Update status
-            dispatch({ type: 'SET_STATUS', payload: 'streaming' });
+            dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'streaming' });
             dispatch({ type: 'SET_ERROR', payload: undefined });
             try {
                 const result = await api.sendMessage(client, agentConfig, chatId, trimmedText, files);
@@ -226,15 +222,14 @@ export function createActions(ctx) {
                 }
                 else {
                     // API returned no result — reset status so we don't get stuck
-                    dispatch({ type: 'SET_STATUS', payload: 'idle' });
-                    dispatch({ type: 'SET_IS_GENERATING', payload: false });
+                    dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
                     callbacks.onStatusChange?.('idle');
                 }
             }
             catch (error) {
                 console.error('[AgentSDK] Failed to send message:', error);
                 const err = error instanceof Error ? error : new Error('Failed to send message');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
             }
@@ -256,7 +251,7 @@ export function createActions(ctx) {
         },
         clearError: () => {
             dispatch({ type: 'SET_ERROR', payload: undefined });
-            dispatch({ type: 'SET_STATUS', payload: 'idle' });
+            dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'idle' });
         },
         submitToolResult: async (toolInvocationId, result) => {
             try {
@@ -265,7 +260,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to submit tool result:', error);
                 const err = error instanceof Error ? error : new Error('Failed to submit tool result');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;
@@ -278,7 +273,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to approve tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to approve tool');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;
@@ -291,7 +286,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to reject tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to reject tool');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;
@@ -309,7 +304,7 @@ export function createActions(ctx) {
             catch (error) {
                 console.error('[AgentSDK] Failed to always-allow tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to always-allow tool');
-                dispatch({ type: 'SET_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
                 dispatch({ type: 'SET_ERROR', payload: err.message });
                 callbacks.onError?.(err);
                 throw error;

package/dist/agent/api.d.ts

@@ -5,15 +5,15 @@
  * Uses the client passed in from the provider.
  */
 import type { ChatDTO, ChatMessageDTO } from '../types';
-import type { AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentClient, UploadedFile } from './types';
+import type { AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentClient, FileRef } from './types';
 /**
  * File input that can be either a File to upload or an already-uploaded file
  */
-export type FileInput = globalThis.File | UploadedFile;
+export type FileInput = globalThis.File | FileRef;
 /**
  * Send a message using ad-hoc agent config
  */
-export declare function sendAdHocMessage(client: AgentClient, config: AdHocAgentConfig, chatId: string | null, text: string, imageUris?: string[], fileUris?: string[]): Promise<{
+export declare function sendAdHocMessage(client: AgentClient, config: AdHocAgentConfig, chatId: string | null, text: string, attachments?: FileRef[]): Promise<{
     chatId: string;
     userMessage: ChatMessageDTO;
     assistantMessage: ChatMessageDTO;
@@ -21,7 +21,7 @@ export declare function sendAdHocMessage(client: AgentClient, config: AdHocAgent
 /**
  * Send a message using template agent config
  */
-export declare function sendTemplateMessage(client: AgentClient, config: TemplateAgentConfig, chatId: string | null, text: string, imageUris?: string[], fileUris?: string[]): Promise<{
+export declare function sendTemplateMessage(client: AgentClient, config: TemplateAgentConfig, chatId: string | null, text: string, attachments?: FileRef[]): Promise<{
     chatId: string;
     userMessage: ChatMessageDTO;
     assistantMessage: ChatMessageDTO;
@@ -67,7 +67,7 @@ export declare function alwaysAllowTool(client: AgentClient, chatId: string, too
 /**
  * Upload a file and return the uploaded file reference
  */
-export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<UploadedFile>;
+export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<FileRef>;
 /**
  * Get streamable config for chat streaming (NDJSON)
  */

package/dist/agent/api.js

@@ -8,13 +8,13 @@ import { isAdHocConfig, extractToolSchemas } from './types';
 /**
  * Check if input is an already-uploaded file
  */
-function isUploadedFile(input) {
+function isFileRef(input) {
     return 'uri' in input && typeof input.uri === 'string';
 }
 /**
  * Send a message using ad-hoc agent config
  */
-export async function sendAdHocMessage(client, config, chatId, text, imageUris, fileUris) {
+export async function sendAdHocMessage(client, config, chatId, text, attachments) {
     // Extract just the schemas from tools (handlers are stripped out)
     const toolSchemas = config.tools ? extractToolSchemas(config.tools) : undefined;
     const request = {
@@ -27,8 +27,7 @@ export async function sendAdHocMessage(client, config, chatId, text, imageUris,
         agent_name: config.name,
         input: {
             text,
-            images: imageUris,
-            files: fileUris,
+            attachments,
             context_size: 0,
             system_prompt: '',
             context: [],
@@ -51,15 +50,14 @@ export async function sendAdHocMessage(client, config, chatId, text, imageUris,
 /**
  * Send a message using template agent config
  */
-export async function sendTemplateMessage(client, config, chatId, text, imageUris, fileUris) {
+export async function sendTemplateMessage(client, config, chatId, text, attachments) {
     const request = {
         chat_id: chatId ?? undefined,
         // Only include agent if it's not empty (for existing chats, backend uses chat's agent)
         agent: config.agent || undefined,
         input: {
             text,
-            images: imageUris,
-            files: fileUris,
+            attachments,
             context_size: 0,
             system_prompt: '',
             context: [],
@@ -83,43 +81,36 @@ export async function sendTemplateMessage(client, config, chatId, text, imageUri
  * Send a message (unified interface)
  */
 export async function sendMessage(client, config, chatId, text, files) {
-    // Process files - upload if needed, or use existing URIs
-    let imageUris;
-    let fileUris;
+    // Process files - upload if needed, collect as FileRef attachments
+    let attachments;
     if (files && files.length > 0) {
-        const uploadedFiles = [];
+        attachments = [];
         for (const file of files) {
-            // Check if already uploaded
-            if (isUploadedFile(file)) {
-                uploadedFiles.push(file);
+            // Check if already uploaded (FileRef)
+            if (isFileRef(file)) {
+                attachments.push(file);
                 continue;
             }
             // Upload the file
             try {
                 const result = await client.files.upload(file);
                 if (result) {
-                    uploadedFiles.push(result);
+                    attachments.push(result);
                 }
             }
             catch (error) {
                 console.error('[AgentSDK] Failed to upload file:', error);
             }
         }
-        // Separate images from other files
-        const images = uploadedFiles.filter(f => f.content_type?.startsWith('image/'));
-        const otherFiles = uploadedFiles.filter(f => !f.content_type?.startsWith('image/'));
-        if (images.length > 0) {
-            imageUris = images.map(f => f.uri);
-        }
-        if (otherFiles.length > 0) {
-            fileUris = otherFiles.map(f => f.uri);
+        if (attachments.length === 0) {
+            attachments = undefined;
         }
     }
     if (isAdHocConfig(config)) {
-        return sendAdHocMessage(client, config, chatId, text, imageUris, fileUris);
+        return sendAdHocMessage(client, config, chatId, text, attachments);
     }
     else {
-        return sendTemplateMessage(client, config, chatId, text, imageUris, fileUris);
+        return sendTemplateMessage(client, config, chatId, text, attachments);
     }
 }
 /**

package/dist/agent/hooks.d.ts

@@ -8,13 +8,14 @@ import type { ChatMessageDTO } from '../types';
 /**
  * Hook to access chat state
  *
- * @returns Chat state (messages, status, isGenerating, etc.)
+ * @returns Chat state (chat, messages, connectionStatus, error)
  * @throws Error if used outside AgentChatProvider
  *
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { messages, isGenerating, status } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *   return <div>{messages.length} messages</div>;
  * }
  * ```
@@ -30,11 +31,12 @@ export declare function useAgentChat(): AgentChatState;
  * ```tsx
  * function SendButton() {
  *   const { sendMessage, stopGeneration } = useAgentActions();
- *   const { isGenerating } = useAgentChat();
+ *   const { chat } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
- *     <button onClick={() => isGenerating ? stopGeneration() : sendMessage('Hello!')}>
- *       {isGenerating ? 'Stop' : 'Send'}
+ *     <button onClick={() => isBusy ? stopGeneration() : sendMessage('Hello!')}>
+ *       {isBusy ? 'Stop' : 'Send'}
  *     </button>
  *   );
  * }
@@ -67,11 +69,12 @@ export declare function useMessage(messageId: string): ChatMessageDTO | undefine
  * function ChatInput() {
  *   const { state, actions } = useAgentChatContext();
  *   const [input, setInput] = useState('');
+ *   const isBusy = state.chat?.status === 'busy';
  *
  *   return (
  *     <form onSubmit={() => actions.sendMessage(input)}>
  *       <input value={input} onChange={e => setInput(e.target.value)} />
- *       <button disabled={state.isGenerating}>Send</button>
+ *       <button disabled={isBusy}>Send</button>
  *     </form>
  *   );
  * }

package/dist/agent/hooks.js

@@ -8,13 +8,14 @@ import { AgentChatContext } from './context';
 /**
  * Hook to access chat state
  *
- * @returns Chat state (messages, status, isGenerating, etc.)
+ * @returns Chat state (chat, messages, connectionStatus, error)
  * @throws Error if used outside AgentChatProvider
  *
  * @example
  * ```tsx
  * function MyComponent() {
- *   const { messages, isGenerating, status } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *   return <div>{messages.length} messages</div>;
  * }
  * ```
@@ -37,11 +38,12 @@ export function useAgentChat() {
  * ```tsx
  * function SendButton() {
  *   const { sendMessage, stopGeneration } = useAgentActions();
- *   const { isGenerating } = useAgentChat();
+ *   const { chat } = useAgentChat();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
- *     <button onClick={() => isGenerating ? stopGeneration() : sendMessage('Hello!')}>
- *       {isGenerating ? 'Stop' : 'Send'}
+ *     <button onClick={() => isBusy ? stopGeneration() : sendMessage('Hello!')}>
+ *       {isBusy ? 'Stop' : 'Send'}
  *     </button>
  *   );
  * }
@@ -84,11 +86,12 @@ export function useMessage(messageId) {
  * function ChatInput() {
  *   const { state, actions } = useAgentChatContext();
  *   const [input, setInput] = useState('');
+ *   const isBusy = state.chat?.status === 'busy';
  *
  *   return (
  *     <form onSubmit={() => actions.sendMessage(input)}>
  *       <input value={input} onChange={e => setInput(e.target.value)} />
- *       <button disabled={state.isGenerating}>Send</button>
+ *       <button disabled={isBusy}>Send</button>
  *     </form>
  *   );
  * }

package/dist/agent/index.d.ts

@@ -29,14 +29,15 @@
  * }
  *
  * function ChatUI() {
- *   const { messages, isGenerating } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
  *   const { sendMessage, stopGeneration } = useAgentActions();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
  *     <div>
  *       {messages.map(m => <Message key={m.id} message={m} />)}
  *       <input onSubmit={(text) => sendMessage(text)} />
- *       {isGenerating && <button onClick={stopGeneration}>Stop</button>}
+ *       {isBusy && <button onClick={stopGeneration}>Stop</button>}
  *     </div>
  *   );
  * }
@@ -45,5 +46,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, } from './types';
+export type { AgentClient, FileRef, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
 export { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';

package/dist/agent/index.js

@@ -29,14 +29,15 @@
  * }
  *
  * function ChatUI() {
- *   const { messages, isGenerating } = useAgentChat();
+ *   const { chat, messages } = useAgentChat();
  *   const { sendMessage, stopGeneration } = useAgentActions();
+ *   const isBusy = chat?.status === 'busy';
  *
  *   return (
  *     <div>
  *       {messages.map(m => <Message key={m.id} message={m} />)}
  *       <input onSubmit={(text) => sendMessage(text)} />
- *       {isGenerating && <button onClick={stopGeneration}>Stop</button>}
+ *       {isBusy && <button onClick={stopGeneration}>Stop</button>}
  *     </div>
  *   );
  * }

package/dist/agent/reducer.js

@@ -9,8 +9,7 @@
 export const initialState = {
     chatId: null,
     messages: [],
-    status: 'idle',
-    isGenerating: false,
+    connectionStatus: 'idle',
     error: undefined,
     chat: null,
 };
@@ -24,12 +23,10 @@ export function chatReducer(state, action) {
         case 'SET_CHAT': {
             const chat = action.payload;
             if (!chat) {
-                return { ...state, chat: null, messages: [], isGenerating: false, status: 'idle' };
+                return { ...state, chat: null, messages: [], connectionStatus: 'idle' };
             }
             const messages = [...(chat.chat_messages || [])].sort((a, b) => a.order - b.order);
-            const isGenerating = chat.status === 'busy';
-            const status = isGenerating ? 'streaming' : 'idle';
-            return { ...state, chat, messages, isGenerating, status };
+            return { ...state, chat, messages };
         }
         case 'SET_MESSAGES':
             return { ...state, messages: action.payload };
@@ -51,14 +48,8 @@ export function chatReducer(state, action) {
                 ...state,
                 messages: [...state.messages, action.payload].sort((a, b) => a.order - b.order),
             };
-        case 'SET_STATUS':
-            return {
-                ...state,
-                status: action.payload,
-                isGenerating: action.payload === 'streaming' || action.payload === 'connecting',
-            };
-        case 'SET_IS_GENERATING':
-            return { ...state, isGenerating: action.payload };
+        case 'SET_CONNECTION_STATUS':
+            return { ...state, connectionStatus: action.payload };
         case 'SET_ERROR':
             return { ...state, error: action.payload };
         case 'RESET':

package/dist/agent/types.d.ts

@@ -4,17 +4,11 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig } from '../types';
+import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfig as GeneratedAgentConfig, CoreAppConfig, FileRef } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
-/**
- * Minimal file interface returned by upload (just needs uri and content_type)
- */
-export interface UploadedFile {
-    uri: string;
-    content_type?: string;
-}
+export type { FileRef } from '../types';
 /**
  * Minimal client interface required by the agent module.
  * This allows extended clients (like the app client) to be used.
@@ -24,7 +18,7 @@ export interface AgentClient {
     http: Pick<HttpClient, 'request' | 'getStreamableConfig' | 'getStreamDefault' | 'getPollIntervalMs'>;
     /** Files API for uploads */
     files: {
-        upload: (data: string | Blob | globalThis.File) => Promise<UploadedFile>;
+        upload: (data: string | Blob | globalThis.File) => Promise<FileRef>;
     };
 }
 /**
@@ -93,11 +87,9 @@ export interface AgentChatState {
     chatId: string | null;
     /** Chat messages */
     messages: ChatMessageDTO[];
-    /** Chat status */
-    status: ChatStatus;
-    /** Whether the agent is currently generating a response */
-    isGenerating: boolean;
-    /** Error message if status is 'error' */
+    /** Connection status (stream/poll state, not chat.status) */
+    connectionStatus: ChatStatus;
+    /** Error message if connectionStatus is 'error' */
     error?: string;
     /** The full chat object (if loaded) */
     chat: ChatDTO | null;
@@ -107,9 +99,9 @@ export interface AgentChatState {
  */
 export interface AgentChatActions {
     /** Send a message to the agent */
-    sendMessage: (text: string, files?: UploadedFile[]) => Promise<void>;
+    sendMessage: (text: string, files?: FileRef[]) => Promise<void>;
     /** Upload a file and return the uploaded file reference */
-    uploadFile: (file: File) => Promise<UploadedFile>;
+    uploadFile: (file: File) => Promise<FileRef>;
     /** Stop the current generation */
     stopGeneration: () => void;
     /** Reset the chat (start fresh) */
@@ -194,11 +186,8 @@ export type ChatAction = {
     type: 'ADD_MESSAGE';
     payload: ChatMessageDTO;
 } | {
-    type: 'SET_STATUS';
+    type: 'SET_CONNECTION_STATUS';
     payload: ChatStatus;
-} | {
-    type: 'SET_IS_GENERATING';
-    payload: boolean;
 } | {
     type: 'SET_ERROR';
     payload: string | undefined;

package/dist/api/files.js

@@ -81,10 +81,15 @@ export class FilesAPI {
                 contentType = 'application/octet-stream';
             }
         }
+        // Extract filename from File object if not provided in options
+        let filename = options.filename;
+        if (!filename && data instanceof globalThis.File) {
+            filename = data.name;
+        }
         // Step 1: Create the file record
         const fileRequest = {
             uri: '', // Empty URI as it will be set by the server
-            filename: options.filename,
+            filename,
             content_type: contentType,
             path: options.path,
             size: data instanceof Blob ? data.size : undefined,

package/dist/http/client.js

@@ -16,7 +16,7 @@ export class HttpClient {
         this.baseUrl = config.baseUrl || 'https://api.inference.sh';
         this.proxyUrl = config.proxyUrl;
         this.getToken = config.getToken;
-        this.customHeaders = config.headers || {};
+        this.customHeaders = { 'User-Agent': 'inference-sdk-js/0.5.13', ...config.headers };
         this.credentials = config.credentials || 'include';
         this.onError = config.onError;
         this.streamDefault = config.stream ?? true;

package/dist/types.d.ts

@@ -227,6 +227,8 @@ export interface AgentDTO extends BaseModel, PermissionModelDTO, ProjectModelDTO
 export interface SkillConfig {
     name: string;
     description: string;
+    skill_id?: string;
+    version_id?: string;
     url?: string;
     content?: string;
 }
@@ -321,6 +323,7 @@ export interface APIResponse<T extends any> {
 export interface APIError {
     code: string;
     message: string;
+    suggestions?: string[];
 }
 /**
  * ApiAppRunRequest is the request body for /apps/run endpoint.
@@ -509,6 +512,17 @@ export interface CreateFlowRunRequest {
     flow: string;
     input: any;
 }
+/**
+ * CreateAppRequest is the request body for POST /apps
+ */
+export interface CreateAppRequest extends App {
+    /**
+     * PreserveCurrentVersion prevents auto-promoting the new version to current.
+     * Default false = new versions become current (what most users expect).
+     * Set true for admin deployments where you want to test before promoting.
+     */
+    preserve_current_version?: boolean;
+}
 /**
  * CreateAgentRequest is the request body for POST /agents
  * For new agents: omit ID, backend generates it
@@ -551,6 +565,13 @@ export interface SkillPublishRequest {
     metadata?: {
         [key: string]: string;
     };
+    /**
+     * Lineage — backend infers MutationType from context
+     */
+    parent_skill_id?: string;
+    parent_version_id?: string;
+    source_url?: string;
+    version_notes?: string;
     /**
      * Spec fields for roundtrip fidelity
      */
@@ -596,6 +617,7 @@ export interface DeviceAuthPollResponse {
 export interface DeviceAuthApproveRequest {
     code: string;
     team_id: string;
+    scopes?: string[];
 }
 /**
  * DeviceAuthApproveResponse is returned after approval
@@ -750,6 +772,51 @@ export interface EngineConfig {
      */
     engine_internal_api_url: string;
 }
+/**
+ * ScopeGroup identifies a category of scopes for UI grouping
+ */
+export type ScopeGroup = string;
+export declare const ScopeGroupAgents: ScopeGroup;
+export declare const ScopeGroupApps: ScopeGroup;
+export declare const ScopeGroupConversations: ScopeGroup;
+export declare const ScopeGroupFiles: ScopeGroup;
+export declare const ScopeGroupDatastores: ScopeGroup;
+export declare const ScopeGroupFlows: ScopeGroup;
+export declare const ScopeGroupProjects: ScopeGroup;
+export declare const ScopeGroupTeams: ScopeGroup;
+export declare const ScopeGroupBilling: ScopeGroup;
+export declare const ScopeGroupSecrets: ScopeGroup;
+export declare const ScopeGroupIntegrations: ScopeGroup;
+export declare const ScopeGroupEngines: ScopeGroup;
+export declare const ScopeGroupApiKeys: ScopeGroup;
+export declare const ScopeGroupUser: ScopeGroup;
+export declare const ScopeGroupSettings: ScopeGroup;
+/**
+ * ScopeDefinition describes a single scope for UI rendering
+ */
+export interface ScopeDefinition {
+    value: string;
+    label: string;
+    description: string;
+    group: ScopeGroup;
+}
+/**
+ * ScopeGroupDefinition describes a group of scopes for UI rendering
+ */
+export interface ScopeGroupDefinition {
+    id: ScopeGroup;
+    label: string;
+    description: string;
+}
+/**
+ * ScopePreset represents a predefined bundle of scopes for common use cases
+ */
+export interface ScopePreset {
+    id: string;
+    label: string;
+    description: string;
+    scopes: string[];
+}
 export type AppCategory = string;
 export declare const AppCategoryImage: AppCategory;
 export declare const AppCategoryVideo: AppCategory;
@@ -1042,6 +1109,17 @@ export declare const IntegrationTypeSlack: IntegrationType;
 export declare const IntegrationTypeDiscord: IntegrationType;
 export declare const IntegrationTypeTeams: IntegrationType;
 export declare const IntegrationTypeTelegram: IntegrationType;
+/**
+ * FileRef is a lightweight reference to a file with essential metadata.
+ * Used in chat inputs/context instead of full File objects.
+ */
+export interface FileRef {
+    id?: string;
+    uri: string;
+    filename: string;
+    content_type: string;
+    size?: number;
+}
 export interface ChatMessageContent {
     type: ChatMessageContentType;
     error?: string;
@@ -1078,6 +1156,13 @@ export interface ChatTaskInput {
     role?: ChatMessageRole;
     text?: string;
     reasoning?: string;
+    /**
+     * Attachments is the SDK input field with full file metadata
+     */
+    attachments?: FileRef[];
+    /**
+     * Images and Files are internal fields for task workers (filled from Attachments or context)
+     */
     images?: string[];
     files?: string[];
     tools?: Tool[];
@@ -1553,6 +1638,9 @@ export declare const GraphEdgeTypeDependency: GraphEdgeType;
 export declare const GraphEdgeTypeFlow: GraphEdgeType;
 export declare const GraphEdgeTypeConditional: GraphEdgeType;
 export declare const GraphEdgeTypeExecution: GraphEdgeType;
+export declare const GraphEdgeTypeParent: GraphEdgeType;
+export declare const GraphEdgeTypeAncestor: GraphEdgeType;
+export declare const GraphEdgeTypeDuplicate: GraphEdgeType;
 /**
  * GraphNodeDTO is the API representation of a graph node
  */
@@ -2272,6 +2360,7 @@ export interface UserMetadata {
     use_case: string;
     use_case_reason: string;
     use_case_privacy: string;
+    signup_source: string;
 }
 /**
  * WidgetAction represents an action triggered by a widget button

package/dist/types.js

@@ -4,6 +4,21 @@ export const ToolTypeAgent = "agent"; // Sub-agent tools - creates a sub-Chat
 export const ToolTypeHook = "hook"; // Webhook tools - HTTP POST to external URL
 export const ToolTypeClient = "client"; // Client tools - executed by frontend
 export const ToolTypeInternal = "internal"; // Internal/built-in tools (plan, memory, widget, finish)
+export const ScopeGroupAgents = "agents";
+export const ScopeGroupApps = "apps";
+export const ScopeGroupConversations = "conversations";
+export const ScopeGroupFiles = "files";
+export const ScopeGroupDatastores = "datastores";
+export const ScopeGroupFlows = "flows";
+export const ScopeGroupProjects = "projects";
+export const ScopeGroupTeams = "teams";
+export const ScopeGroupBilling = "billing";
+export const ScopeGroupSecrets = "secrets";
+export const ScopeGroupIntegrations = "integrations";
+export const ScopeGroupEngines = "engines";
+export const ScopeGroupApiKeys = "apikeys";
+export const ScopeGroupUser = "user";
+export const ScopeGroupSettings = "settings";
 export const AppCategoryImage = "image";
 export const AppCategoryVideo = "video";
 export const AppCategoryAudio = "audio";
@@ -109,6 +124,9 @@ export const GraphEdgeTypeDependency = "dependency"; // Blocking dependency
 export const GraphEdgeTypeFlow = "flow"; // Non-blocking flow
 export const GraphEdgeTypeConditional = "conditional"; // Conditional flow
 export const GraphEdgeTypeExecution = "execution"; // Node → Resource execution link
+export const GraphEdgeTypeParent = "parent"; // Parent resource → child resource (e.g. skill fork)
+export const GraphEdgeTypeAncestor = "ancestor"; // Specific version → child resource (fork point)
+export const GraphEdgeTypeDuplicate = "duplicate"; // Skill → skill with identical content hash
 export const ProjectTypeAgent = "agent";
 export const ProjectTypeApp = "app";
 export const ProjectTypeFlow = "flow";

package/package.json

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