@inferencesh/sdk 0.6.30 → 0.6.48

package/dist/agent/provider.js

@@ -9,6 +9,8 @@ import { useReducer, useRef, useEffect, useMemo } from 'react';
 import { AgentChatContext } from './context';
 import { chatReducer, initialState } from './reducer';
 import { createActions, getClientToolHandlers } from './actions';
+import { fetchAgentInfo } from './api';
+import { isTemplateConfig } from './types';
 function mergeHandlers(base, extra) {
     if (!extra || extra.size === 0)
         return base;
@@ -62,7 +64,9 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
         streamRef.current = stream;
         pollIntervalMsRef.current = pollIntervalMs;
     }, [stream, pollIntervalMs]);
-    // Keep chatIdRef synced with state
+    // Keep refs synced with state
+    const stateRef = useRef(state);
+    stateRef.current = state;
     useEffect(() => {
         chatIdRef.current = state.chatId;
     }, [state.chatId]);
@@ -70,6 +74,7 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
     const actionsContext = useMemo(() => ({
         client,
         dispatch,
+        getState: () => stateRef.current,
         getConfig: () => configRef.current,
         getChatId: () => chatIdRef.current,
         getClientToolHandlers: () => clientToolHandlersRef.current,
@@ -88,6 +93,18 @@ export function AgentChatProvider({ client, agentConfig, chatId, clientToolHandl
         actionsResultRef.current = createActions(actionsContext);
     }
     const { publicActions, internalActions } = actionsResultRef.current;
+    // Fetch agent info for template configs (example_prompts, description)
+    const agentRef = isTemplateConfig(agentConfig) ? agentConfig.agent : null;
+    useEffect(() => {
+        if (!agentRef)
+            return;
+        let stale = false;
+        fetchAgentInfo(client, agentRef).then((info) => {
+            if (info && !stale)
+                dispatch({ type: 'SET_AGENT_INFO', payload: info });
+        });
+        return () => { stale = true; };
+    }, [client, agentRef]);
     // Handle initial chatId or chatId changes
     useEffect(() => {
         if (chatId && chatId !== state.chatId) {

package/dist/agent/reducer.js

@@ -3,6 +3,16 @@
  *
  * Pure reducer for managing agent chat state.
  */
+import { ChatStatusBusy, ChatStatusAwaitingInput, ChatStatusIdle, AgentRunStateWorking, AgentRunStateSubmitted } from '../types';
+function deriveChatStatus(run) {
+    if (!run)
+        return ChatStatusIdle;
+    if (run.state === AgentRunStateWorking || run.state === AgentRunStateSubmitted)
+        return ChatStatusBusy;
+    if (run.state === 'input_required' || run.state === 'auth_required')
+        return ChatStatusAwaitingInput;
+    return ChatStatusIdle;
+}
 // =============================================================================
 // Initial State
 // =============================================================================
@@ -12,6 +22,8 @@ export const initialState = {
     connectionStatus: 'idle',
     error: undefined,
     chat: null,
+    messageCursor: undefined,
+    hasOlderMessages: undefined,
 };
 // =============================================================================
 // Reducer
@@ -23,10 +35,12 @@ export function chatReducer(state, action) {
         case 'SET_CHAT': {
             const chat = action.payload;
             if (!chat) {
-                return { ...state, chat: null, messages: [], connectionStatus: 'idle' };
+                return { ...state, chat: null, messages: [], connectionStatus: 'idle', messageCursor: undefined, hasOlderMessages: undefined };
             }
             const messages = [...(chat.chat_messages || [])].sort((a, b) => a.order - b.order);
-            return { ...state, chat, messages };
+            const cursor = chat?._messageCursor;
+            const hasOlder = chat?._hasOlderMessages;
+            return { ...state, chat, messages, messageCursor: cursor, hasOlderMessages: hasOlder };
         }
         case 'UPDATE_CHAT': {
             // Update chat metadata without replacing messages
@@ -38,34 +52,59 @@ export function chatReducer(state, action) {
         case 'UPDATE_ACTIVE_RUN': {
             if (!state.chat)
                 return state;
-            return { ...state, chat: { ...state.chat, active_run: action.payload } };
+            return { ...state, chat: { ...state.chat, active_run: action.payload, status: deriveChatStatus(action.payload) } };
         }
         case 'SET_MESSAGES':
             return { ...state, messages: action.payload };
+        case 'PREPEND_MESSAGES': {
+            const { messages: older, cursor, hasMore } = action.payload;
+            const existingIds = new Set(state.messages.map(m => m.id));
+            const deduped = older.filter(m => !existingIds.has(m.id));
+            const merged = [...deduped, ...state.messages].sort((a, b) => a.order - b.order);
+            return { ...state, messages: merged, messageCursor: cursor, hasOlderMessages: hasMore };
+        }
         case 'UPDATE_MESSAGE': {
             const message = action.payload;
             const existingIndex = state.messages.findIndex((m) => m.id === message.id);
-            let newMessages;
             if (existingIndex !== -1) {
-                newMessages = [...state.messages];
-                newMessages[existingIndex] = message;
+                const existing = state.messages[existingIndex];
+                const updated = action.partial ? { ...existing, ...message } : message;
+                if (existing === updated)
+                    return state;
+                const newMessages = [...state.messages];
+                newMessages[existingIndex] = updated;
+                return { ...state, messages: newMessages };
             }
-            else {
-                newMessages = [...state.messages, message].sort((a, b) => a.order - b.order);
-            }
-            return { ...state, messages: newMessages };
+            if (action.partial)
+                return state;
+            return { ...state, messages: [...state.messages, message].sort((a, b) => a.order - b.order) };
         }
         case 'ADD_MESSAGE':
             return {
                 ...state,
                 messages: [...state.messages, action.payload].sort((a, b) => a.order - b.order),
             };
+        case 'DELTA_TOKEN': {
+            const output = action.payload;
+            const msgs = state.messages;
+            const lastAssistant = [...msgs].reverse().find(m => m.role === 'assistant');
+            if (!lastAssistant)
+                return state;
+            const textBlock = lastAssistant.content?.find(c => c.type === 'text');
+            const newContent = textBlock
+                ? lastAssistant.content.map(c => c.type === 'text' ? { ...c, text: output.response } : c)
+                : [{ type: 'text', text: output.response }, ...lastAssistant.content];
+            const newMessages = msgs.map(m => m.id === lastAssistant.id ? { ...lastAssistant, content: newContent } : m);
+            return { ...state, messages: newMessages };
+        }
         case 'SET_CONNECTION_STATUS':
             return { ...state, connectionStatus: action.payload };
         case 'SET_ERROR':
             return { ...state, error: action.payload };
+        case 'SET_AGENT_INFO':
+            return { ...state, agentInfo: action.payload };
         case 'RESET':
-            return initialState;
+            return { ...initialState, agentInfo: state.agentInfo };
         default:
             return state;
     }

package/dist/agent/types.d.ts

@@ -4,7 +4,7 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { AgentRunDTO, ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef } from '../types';
+import type { AgentRunDTO, AgentVersionDTO, ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
@@ -81,6 +81,10 @@ export declare function isAdHocConfig(config: AgentOptions): config is AdHocAgen
  * Type guard to check if config is template-based
  */
 export declare function isTemplateConfig(config: AgentOptions): config is TemplateAgentConfig;
+/**
+ * Agent metadata fetched from the backend for template configs
+ */
+export type AgentInfo = Partial<Pick<AgentVersionDTO, 'description' | 'example_prompts'>>;
 /**
  * Status of the chat
  */
@@ -99,6 +103,12 @@ export interface AgentChatState {
     error?: string;
     /** The full chat object (if loaded) */
     chat: ChatDTO | null;
+    /** Cursor for loading older messages */
+    messageCursor?: string;
+    /** Whether older messages exist beyond the current page */
+    hasOlderMessages?: boolean;
+    /** Agent info fetched from the backend (description, example_prompts) */
+    agentInfo?: AgentInfo;
 }
 /**
  * Actions available for interacting with the chat
@@ -122,6 +132,14 @@ export interface AgentChatActions {
     rejectTool: (toolInvocationId: string, reason?: string) => Promise<void>;
     /** Always allow a tool for this chat (approves + auto-approves future invocations) */
     alwaysAllowTool: (toolInvocationId: string, toolName: string) => Promise<void>;
+    /** Cancel a queued message before the agent processes it */
+    cancelMessage: (messageId: string) => Promise<void>;
+    /** Resolve an interrupt gate (allow or deny) */
+    resolveInterrupt: (interruptId: string, decision: 'allow' | 'deny') => Promise<void>;
+    /** Load older messages (scroll-up pagination). Returns true if more exist. */
+    loadOlderMessages: () => Promise<boolean>;
+    /** Whether there are older messages to load */
+    hasOlderMessages: boolean;
 }
 /**
  * Props for the AgentChatProvider
@@ -196,15 +214,29 @@ export type ChatAction = {
 } | {
     type: 'UPDATE_MESSAGE';
     payload: ChatMessageDTO;
+    partial?: boolean;
 } | {
     type: 'ADD_MESSAGE';
     payload: ChatMessageDTO;
+} | {
+    type: 'DELTA_TOKEN';
+    payload: Record<string, any>;
 } | {
     type: 'SET_CONNECTION_STATUS';
     payload: ChatStatus;
 } | {
     type: 'SET_ERROR';
     payload: string | undefined;
+} | {
+    type: 'PREPEND_MESSAGES';
+    payload: {
+        messages: ChatMessageDTO[];
+        cursor?: string;
+        hasMore: boolean;
+    };
+} | {
+    type: 'SET_AGENT_INFO';
+    payload: AgentInfo;
 } | {
     type: 'RESET';
 };
@@ -216,6 +248,7 @@ export type UpdateManager = StreamableManager<unknown> | PollManager<unknown>;
 export interface ActionsContext {
     client: AgentClient;
     dispatch: Dispatch<ChatAction>;
+    getState: () => AgentChatState;
     getConfig: () => AgentOptions | null;
     getChatId: () => string | null;
     getClientToolHandlers: () => Map<string, ClientToolHandlerFn>;

package/dist/api/agents.d.ts

@@ -1,6 +1,7 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { FilesAPI } from './files';
-import { ChatDTO, ChatMessageDTO, AgentConfigInput as AgentConfig, AgentDTO, AgentVersionDTO, CreateAgentRequest, FileDTO as File, CursorListRequest, CursorListResponse } from '../types';
+import { ChatDTO, ChatMessageDTO, AgentConfigInput as AgentConfig, AgentDTO, AgentVersionDTO, CreateAgentRequest, FileDTO as File, InterruptDTO, CursorListRequest, CursorListResponse } from '../types';
 /** Internal tool definition returned by getInternalTools */
 export interface InternalToolDefinition {
     id: string;
@@ -107,57 +108,57 @@ export declare class AgentsAPI {
     /**
      * List agent templates with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<AgentDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<AgentDTO>>>;
     /**
      * Get an agent template by ID
      */
-    get(agentId: string): Promise<AgentDTO>;
+    get(agentId: string): Promise<Response<AgentDTO>>;
     /**
      * Create a new agent template or create a new version of an existing agent
      */
-    createAgent(data: CreateAgentRequest): Promise<AgentDTO>;
+    createAgent(data: CreateAgentRequest): Promise<Response<AgentDTO>>;
     /**
      * Update an agent template
      */
-    update(agentId: string, data: Partial<AgentDTO>): Promise<AgentDTO>;
+    update(agentId: string, data: Partial<AgentDTO>): Promise<Response<AgentDTO>>;
     /**
      * Delete an agent template
      */
-    delete(agentId: string): Promise<void>;
+    delete(agentId: string): Promise<Response<void>>;
     /**
      * Duplicate an agent template
      */
-    duplicate(agentId: string): Promise<AgentDTO>;
+    duplicate(agentId: string): Promise<Response<AgentDTO>>;
     /**
      * List agent template versions
      */
-    listVersions(agentId: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<AgentVersionDTO>>;
+    listVersions(agentId: string, params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<AgentVersionDTO>>>;
     /**
      * Transfer agent ownership to another team
      */
-    transferOwnership(agentId: string, newTeamId: string): Promise<AgentDTO>;
+    transferOwnership(agentId: string, newTeamId: string): Promise<Response<AgentDTO>>;
     /**
      * Update agent visibility
      */
-    updateVisibility(agentId: string, visibility: string): Promise<AgentDTO>;
+    updateVisibility(agentId: string, visibility: string): Promise<Response<AgentDTO>>;
     /**
      * Get a specific agent version
      */
-    getVersion(agentId: string, versionId: string): Promise<AgentVersionDTO>;
+    getVersion(agentId: string, versionId: string): Promise<Response<AgentVersionDTO>>;
     /**
      * Get an agent by namespace/name (e.g., "inference/my-agent")
      */
-    getByName(namespace: string, name: string): Promise<AgentDTO>;
+    getByName(namespace: string, name: string): Promise<Response<AgentDTO>>;
     /**
      * Get internal tools for the agent
      */
-    getInternalTools(): Promise<InternalToolDefinition[]>;
+    getInternalTools(): Promise<Response<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>>;
+    getA2ACard(agentId: string): Promise<Response<Record<string, unknown>>>;
     /**
      * Create an agent instance for chat interactions
      */
@@ -172,5 +173,13 @@ export declare class AgentsAPI {
         };
         form_data?: Record<string, unknown>;
     }): Promise<void>;
+    /**
+     * Resolve an interrupt gate on an agent run
+     */
+    resolveInterrupt(interruptId: string, decision: 'allow' | 'deny'): Promise<Response<InterruptDTO>>;
+    /**
+     * List pending interrupts for an agent run
+     */
+    listRunInterrupts(runId: string): Promise<Response<InterruptDTO[]>>;
 }
 export declare function createAgentsAPI(http: HttpClient, files: FilesAPI): AgentsAPI;

package/dist/api/agents.js

@@ -77,7 +77,8 @@ export class Agent {
             waitPromise = waitFn(options);
         }
         // Make the POST request
-        const response = await this.http.request('post', '/agents/run', { data: body });
+        const resp = await this.http.request('post', '/agents/run', { data: body });
+        const response = resp.data;
         // For new chats: Set chatId and start waiting immediately after POST
         const isNewChat = !this.chatId && response.assistant_message.chat_id;
         if (isNewChat) {
@@ -97,7 +98,8 @@ export class Agent {
         const id = chatId || this.chatId;
         if (!id)
             return null;
-        return this.http.request('get', `/chats/${id}`);
+        const resp = await this.http.request('get', `/chats/${id}`);
+        return resp.data;
     }
     /** Stop the current chat generation */
     async stopChat() {
@@ -202,13 +204,15 @@ export class Agent {
             this.poller = new PollManager({
                 pollFunction: async () => {
                     // Lightweight status check first
-                    const status = await this.http.request('get', `/chats/${this.chatId}/status`);
+                    const statusResp = await this.http.request('get', `/chats/${this.chatId}/status`);
+                    const status = statusResp.data;
                     if (status.status === prevStatus) {
                         // No change — return a stub to skip processing
                         return { status: status.status };
                     }
                     // Status changed — fetch full chat
-                    return this.http.request('get', `/chats/${this.chatId}`);
+                    const chatResp = await this.http.request('get', `/chats/${this.chatId}`);
+                    return chatResp.data;
                 },
                 intervalMs,
                 onData: (chat) => {
@@ -365,6 +369,20 @@ export class AgentsAPI {
         const result = typeof resultOrAction === 'string' ? resultOrAction : JSON.stringify(resultOrAction);
         await this.http.request('post', `/tools/${toolInvocationId}`, { data: { result } });
     }
+    /**
+     * Resolve an interrupt gate on an agent run
+     */
+    async resolveInterrupt(interruptId, decision) {
+        return this.http.request('post', `/interrupts/${interruptId}/resolve`, {
+            data: { decision }
+        });
+    }
+    /**
+     * List pending interrupts for an agent run
+     */
+    async listRunInterrupts(runId) {
+        return this.http.request('get', `/agent-runs/${runId}/interrupts`);
+    }
 }
 export function createAgentsAPI(http, files) {
     return new AgentsAPI(http, files);

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

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

package/dist/api/apps.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { AppDTO as App, AppVersionDTO, CursorListRequest, CursorListResponse, LicenseRecordDTO } from '../types';
 /**
  * Apps API
@@ -9,62 +10,62 @@ export declare class AppsAPI {
     /**
      * List apps with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<App>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<App>>>;
     /**
      * Get an app by ID
      */
-    get(appId: string): Promise<App>;
+    get(appId: string): Promise<Response<App>>;
     /**
      * Get an app by version ID
      */
-    getByVersionId(appId: string, versionId: string): Promise<App>;
+    getByVersionId(appId: string, versionId: string): Promise<Response<App>>;
     /**
      * Create a new app
      */
-    create(data: Partial<App>): Promise<App>;
+    create(data: Partial<App>): Promise<Response<App>>;
     /**
      * Update an app
      */
-    update(appId: string, data: Partial<App>): Promise<App>;
+    update(appId: string, data: Partial<App>): Promise<Response<App>>;
     /**
      * Delete an app
      */
-    delete(appId: string): Promise<void>;
+    delete(appId: string): Promise<Response<void>>;
     /**
      * Duplicate an app
      */
-    duplicate(appId: string): Promise<App>;
+    duplicate(appId: string): Promise<Response<App>>;
     /**
      * List app versions
      */
-    listVersions(appId: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<AppVersionDTO>>;
+    listVersions(appId: string, params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<AppVersionDTO>>>;
     /**
      * Transfer app ownership to another team
      */
-    transferOwnership(appId: string, newTeamId: string): Promise<App>;
+    transferOwnership(appId: string, newTeamId: string): Promise<Response<App>>;
     /**
      * Update app visibility
      */
-    updateVisibility(appId: string, visibility: string): Promise<App>;
+    updateVisibility(appId: string, visibility: string): Promise<Response<App>>;
     /**
      * Update app lifecycle status
      */
-    updateStatus(appId: string, status: string, message?: string): Promise<App>;
+    updateStatus(appId: string, status: string, message?: string): Promise<Response<App>>;
     /**
      * Get an app by namespace and name (e.g., "inference/claude-haiku")
      */
-    getByName(name: string): Promise<App>;
+    getByName(name: string): Promise<Response<App>>;
     /**
      * Get app license record
      */
-    getLicense(appId: string): Promise<LicenseRecordDTO>;
+    getLicense(appId: string): Promise<Response<LicenseRecordDTO>>;
     /**
      * Save app license
      */
-    saveLicense(appId: string, license: string): Promise<LicenseRecordDTO>;
+    saveLicense(appId: string, license: string): Promise<Response<LicenseRecordDTO>>;
     /**
      * Set the current (active) version of an app
      */
-    setCurrentVersion(appId: string, versionId: string): Promise<App>;
+    setCurrentVersion(appId: string, versionId: string): Promise<Response<App>>;
 }
 export declare function createAppsAPI(http: HttpClient): AppsAPI;

package/dist/api/chats.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
-import { ChatDTO as Chat, ChatTraceDTO, CursorListRequest, CursorListResponse } from '../types';
+import type { Response } from '../http/response';
+import { ChatDTO as Chat, ChatMessageDTO, ChatTraceDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Chats API
  */
@@ -9,33 +10,37 @@ export declare class ChatsAPI {
     /**
      * List chats with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Chat>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<Chat>>>;
     /**
      * Get a chat by ID
      */
-    get(chatId: string): Promise<Chat>;
+    get(chatId: string): Promise<Response<Chat>>;
     /**
      * Update a chat
      */
-    update(chatId: string, data: Partial<Chat>): Promise<Chat>;
+    update(chatId: string, data: Partial<Chat>): Promise<Response<Chat>>;
     /**
      * Delete a chat
      */
-    delete(chatId: string): Promise<void>;
+    delete(chatId: string): Promise<Response<void>>;
     /**
      * Get chat trace (for debugging/observability)
      */
-    getTrace(chatId: string): Promise<ChatTraceDTO>;
+    getTrace(chatId: string): Promise<Response<ChatTraceDTO>>;
     /**
      * Get chat status
      */
-    getStatus(chatId: string): Promise<{
+    getStatus(chatId: string): Promise<Response<{
         status: string;
-    }>;
+    }>>;
     /**
      * Stop chat generation
      */
-    stop(chatId: string): Promise<void>;
+    stop(chatId: string): Promise<Response<void>>;
+    /**
+     * Cancel a queued message
+     */
+    cancelMessage(messageId: string): Promise<Response<ChatMessageDTO>>;
     /**
      * Stream chat updates
      */

package/dist/api/chats.js

@@ -47,6 +47,12 @@ export class ChatsAPI {
     async stop(chatId) {
         return this.http.request('post', `/chats/${chatId}/stop`);
     }
+    /**
+     * Cancel a queued message
+     */
+    async cancelMessage(messageId) {
+        return this.http.request('post', `/chats/messages/${messageId}/cancel`);
+    }
     /**
      * Stream chat updates
      */

package/dist/api/engines.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { EngineDTO as Engine, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Engines API
@@ -9,30 +10,30 @@ export declare class EnginesAPI {
     /**
      * List engines with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Engine>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<Engine>>>;
     /**
      * Get an engine by ID
      */
-    get(engineId: string): Promise<Engine>;
+    get(engineId: string): Promise<Response<Engine>>;
     /**
      * Get engines for specific resources (apps/agents)
      */
     getForResources(request: {
         app_ids?: string[];
         agent_ids?: string[];
-    }): Promise<Engine[]>;
+    }): Promise<Response<Engine[]>>;
     /**
      * Create a new engine
      */
-    create(data: Partial<Engine>): Promise<Engine>;
+    create(data: Partial<Engine>): Promise<Response<Engine>>;
     /**
      * Update an engine
      */
-    update(engineId: string, data: Partial<Engine>): Promise<Engine>;
+    update(engineId: string, data: Partial<Engine>): Promise<Response<Engine>>;
     /**
      * Delete an engine
      */
-    delete(engineId: string): Promise<void>;
+    delete(engineId: string): Promise<Response<void>>;
     /**
      * Stream engine updates
      */
@@ -40,30 +41,30 @@ export declare class EnginesAPI {
     /**
      * Stop an engine
      */
-    stop(engineId: string): Promise<void>;
+    stop(engineId: string): Promise<Response<void>>;
     /**
      * Restart an engine
      */
-    restart(engineId: string): Promise<void>;
+    restart(engineId: string): Promise<Response<void>>;
     /**
      * Update engine visibility
      */
-    updateVisibility(engineId: string, visibility: string): Promise<Engine>;
+    updateVisibility(engineId: string, visibility: string): Promise<Response<Engine>>;
     /**
      * Transfer engine ownership
      */
-    transferOwnership(engineId: string, newTeamId: string): Promise<Engine>;
+    transferOwnership(engineId: string, newTeamId: string): Promise<Response<Engine>>;
     /**
      * Extend engine duration
      */
-    extend(engineId: string): Promise<void>;
+    extend(engineId: string): Promise<Response<void>>;
     /**
      * Drain an engine
      */
-    drain(engineId: string): Promise<void>;
+    drain(engineId: string): Promise<Response<void>>;
     /**
      * Update an engine binary (drain + restart with new version)
      */
-    updateBinary(engineId: string): Promise<void>;
+    updateBinary(engineId: string): Promise<Response<void>>;
 }
 export declare function createEnginesAPI(http: HttpClient): EnginesAPI;