@inferencesh/sdk 0.6.29 → 0.6.47

package/dist/api/files.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { FileDTO as File, CursorListRequest, CursorListResponse } from '../types';
 export interface UploadFileOptions {
     filename?: string;
@@ -34,15 +35,15 @@ export declare class FilesAPI {
     /**
      * List files with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<File>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<File>>>;
     /**
      * Get a file by ID
      */
-    get(fileId: string): Promise<File>;
+    get(fileId: string): Promise<Response<File>>;
     /**
      * Delete a file
      */
-    delete(fileId: string): Promise<void>;
+    delete(fileId: string): Promise<Response<void>>;
     /**
      * Upload a file (Blob or base64 string)
      */

package/dist/api/files.js

@@ -129,10 +129,10 @@ export class FilesAPI {
             path: options.path,
             size: resolved.size,
         };
-        const response = await this.http.request('post', '/files', {
+        const resp = await this.http.request('post', '/files', {
             data: { files: [fileRequest] },
         });
-        const file = response[0];
+        const file = resp.data[0];
         // Step 2: Upload the file content to the provided upload_url
         if (!file.upload_url) {
             throw new Error('No upload URL provided by the server');

package/dist/api/flow-runs.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { FlowRunDTO as FlowRun, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Flow Runs API
@@ -9,27 +10,27 @@ export declare class FlowRunsAPI {
     /**
      * List flow runs with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<FlowRun>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<FlowRun>>>;
     /**
      * Get a flow run by ID
      */
-    get(flowRunId: string): Promise<FlowRun>;
+    get(flowRunId: string): Promise<Response<FlowRun>>;
     /**
      * Create a new flow run
      */
-    create(flowId: string, input?: unknown): Promise<FlowRun>;
+    create(flowId: string, input?: unknown): Promise<Response<FlowRun>>;
     /**
      * Clone a flow run
      */
-    clone(flowRunId: string): Promise<FlowRun>;
+    clone(flowRunId: string): Promise<Response<FlowRun>>;
     /**
      * Update a flow run
      */
-    update(flowRunId: string, data: Partial<FlowRun>): Promise<FlowRun>;
+    update(flowRunId: string, data: Partial<FlowRun>): Promise<Response<FlowRun>>;
     /**
      * Cancel a flow run
      */
-    cancel(flowRunId: string): Promise<void>;
+    cancel(flowRunId: string): Promise<Response<void>>;
     /**
      * Stream flow run updates
      */
@@ -41,6 +42,6 @@ export declare class FlowRunsAPI {
     /**
      * Update flow run visibility
      */
-    updateVisibility(flowRunId: string, visibility: string): Promise<FlowRun>;
+    updateVisibility(flowRunId: string, visibility: string): Promise<Response<FlowRun>>;
 }
 export declare function createFlowRunsAPI(http: HttpClient): FlowRunsAPI;

package/dist/api/flows.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { FlowDTO as Flow, FlowVersionDTO, AppDTO as App, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Flows API
@@ -9,43 +10,43 @@ export declare class FlowsAPI {
     /**
      * List flows with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Flow>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<Flow>>>;
     /**
      * Get a flow by ID
      */
-    get(flowId: string): Promise<Flow>;
+    get(flowId: string): Promise<Response<Flow>>;
     /**
      * Create a new flow
      */
-    create(name: string): Promise<Flow>;
+    create(name: string): Promise<Response<Flow>>;
     /**
      * Update a flow
      */
-    update(flowId: string, data: Partial<Flow>): Promise<Flow>;
+    update(flowId: string, data: Partial<Flow>): Promise<Response<Flow>>;
     /**
      * Update flow visibility
      */
-    updateVisibility(flowId: string, visibility: string): Promise<Flow>;
+    updateVisibility(flowId: string, visibility: string): Promise<Response<Flow>>;
     /**
      * Delete a flow
      */
-    delete(flowId: string): Promise<void>;
+    delete(flowId: string): Promise<Response<void>>;
     /**
      * Duplicate a flow
      */
-    duplicate(flowId: string): Promise<Flow>;
+    duplicate(flowId: string): Promise<Response<Flow>>;
     /**
      * List flow versions
      */
-    listVersions(flowId: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<FlowVersionDTO>>;
+    listVersions(flowId: string, params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<FlowVersionDTO>>>;
     /**
      * Create an app from a flow
      */
-    createApp(flowId: string): Promise<App>;
+    createApp(flowId: string): Promise<Response<App>>;
     /**
      * Transfer flow ownership to another team
      */
-    transferOwnership(flowId: string, newTeamId: string): Promise<Flow>;
+    transferOwnership(flowId: string, newTeamId: string): Promise<Response<Flow>>;
     /**
      * Stream flow updates
      */

package/dist/api/integrations.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { IntegrationDTO, IntegrationConfigDTO, IntegrationConnectRequest, IntegrationConnectResponse, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Integrations API
@@ -9,33 +10,33 @@ export declare class IntegrationsAPI {
     /**
      * List integrations with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<IntegrationDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<IntegrationDTO>>>;
     /**
      * Get available integrations
      */
-    listAvailable(): Promise<IntegrationConfigDTO[]>;
+    listAvailable(): Promise<Response<IntegrationConfigDTO[]>>;
     /**
      * Get integration configs
      */
-    getConfigs(): Promise<IntegrationConfigDTO[]>;
+    getConfigs(): Promise<Response<IntegrationConfigDTO[]>>;
     /**
      * Get capabilities
      */
-    getCapabilities(): Promise<unknown>;
+    getCapabilities(): Promise<Response<unknown>>;
     /**
      * Check requirements
      */
-    checkRequirements(data: unknown): Promise<unknown>;
+    checkRequirements(data: unknown): Promise<Response<unknown>>;
     /**
      * Connect an integration
      */
-    connect(data: IntegrationConnectRequest): Promise<IntegrationConnectResponse>;
+    connect(data: IntegrationConnectRequest): Promise<Response<IntegrationConnectResponse>>;
     /**
      * Get an integration by provider key
      */
-    get(provider: string): Promise<IntegrationDTO>;
+    get(provider: string): Promise<Response<IntegrationDTO>>;
     /**
      * Disconnect an integration
      */
-    disconnect(provider: string): Promise<void>;
+    disconnect(provider: string): Promise<Response<void>>;
 }

package/dist/api/integrations.js

@@ -9,48 +9,48 @@ export class IntegrationsAPI {
      * List integrations with cursor-based pagination
      */
     async list(params) {
-        return this.http.request('post', '/integrations/list', { data: params });
+        return this.http.request('post', '/credentials/list', { data: params });
     }
     /**
      * Get available integrations
      */
     async listAvailable() {
-        return this.http.request('get', '/integrations/available');
+        return this.http.request('get', '/credentials/available');
     }
     /**
      * Get integration configs
      */
     async getConfigs() {
-        return this.http.request('get', '/integrations/configs');
+        return this.http.request('get', '/credentials/configs');
     }
     /**
      * Get capabilities
      */
     async getCapabilities() {
-        return this.http.request('get', '/integrations/capabilities');
+        return this.http.request('get', '/credentials/capabilities');
     }
     /**
      * Check requirements
      */
     async checkRequirements(data) {
-        return this.http.request('post', '/integrations/check', { data });
+        return this.http.request('post', '/credentials/check', { data });
     }
     /**
      * Connect an integration
      */
     async connect(data) {
-        return this.http.request('post', '/integrations', { data });
+        return this.http.request('post', '/credentials', { data });
     }
     /**
      * Get an integration by provider key
      */
     async get(provider) {
-        return this.http.request('get', `/integrations/${provider}`);
+        return this.http.request('get', `/credentials/${provider}`);
     }
     /**
      * Disconnect an integration
      */
     async disconnect(provider) {
-        return this.http.request('delete', `/integrations/${provider}`);
+        return this.http.request('delete', `/credentials/${provider}`);
     }
 }

package/dist/api/knowledge.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { KnowledgeDTO, KnowledgeVersionDTO, KnowledgeCreateRequest, SkillDTO, SkillVersionDTO, CursorListRequest, CursorListResponse, PublicSkillStoreDTO } from '../types';
 /**
  * Knowledge API
@@ -9,43 +10,43 @@ export declare class KnowledgeAPI {
     /**
      * List knowledge entries with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<KnowledgeDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<KnowledgeDTO>>>;
     /**
      * Get a knowledge entry by ID
      */
-    get(id: string): Promise<KnowledgeDTO>;
+    get(id: string): Promise<Response<KnowledgeDTO>>;
     /**
      * Get a knowledge entry by namespace/name
      */
-    getByName(namespace: string, name: string): Promise<KnowledgeDTO>;
+    getByName(namespace: string, name: string): Promise<Response<KnowledgeDTO>>;
     /**
      * Create a knowledge entry
      */
-    create(data: KnowledgeCreateRequest): Promise<KnowledgeDTO>;
+    create(data: KnowledgeCreateRequest): Promise<Response<KnowledgeDTO>>;
     /**
      * Update a knowledge entry
      */
-    update(id: string, data: Partial<KnowledgeDTO>): Promise<KnowledgeDTO>;
+    update(id: string, data: Partial<KnowledgeDTO>): Promise<Response<KnowledgeDTO>>;
     /**
      * Delete a knowledge entry
      */
-    delete(id: string): Promise<void>;
+    delete(id: string): Promise<Response<void>>;
     /**
      * List knowledge versions
      */
-    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<KnowledgeVersionDTO>>;
+    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<KnowledgeVersionDTO>>>;
     /**
      * Get a specific version
      */
-    getVersion(id: string, versionId: string): Promise<KnowledgeVersionDTO>;
+    getVersion(id: string, versionId: string): Promise<Response<KnowledgeVersionDTO>>;
     /**
      * Transfer ownership
      */
-    transferOwnership(id: string, newTeamId: string): Promise<KnowledgeDTO>;
+    transferOwnership(id: string, newTeamId: string): Promise<Response<KnowledgeDTO>>;
     /**
      * Update visibility
      */
-    updateVisibility(id: string, visibility: string): Promise<KnowledgeDTO>;
+    updateVisibility(id: string, visibility: string): Promise<Response<KnowledgeDTO>>;
 }
 /**
  * Skills API
@@ -56,57 +57,57 @@ export declare class SkillsAPI {
     /**
      * List skills with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<SkillDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<SkillDTO>>>;
     /**
      * Get a skill by ID
      */
-    get(id: string): Promise<SkillDTO>;
+    get(id: string): Promise<Response<SkillDTO>>;
     /**
      * Get a skill by namespace/name
      */
-    getByName(namespace: string, name: string): Promise<SkillDTO>;
+    getByName(namespace: string, name: string): Promise<Response<SkillDTO>>;
     /**
      * Resolve a skill (store + GitHub fallback)
      */
-    resolve(ref: string, skill?: string): Promise<unknown>;
+    resolve(ref: string, skill?: string): Promise<Response<unknown>>;
     /**
      * Create/publish a skill
      */
-    create(data: Partial<SkillDTO>): Promise<SkillDTO>;
+    create(data: Partial<SkillDTO>): Promise<Response<SkillDTO>>;
     /**
      * Update a skill
      */
-    update(id: string, data: Partial<SkillDTO>): Promise<SkillDTO>;
+    update(id: string, data: Partial<SkillDTO>): Promise<Response<SkillDTO>>;
     /**
      * Delete a skill
      */
-    delete(id: string): Promise<void>;
+    delete(id: string): Promise<Response<void>>;
     /**
      * List skill versions
      */
-    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<CursorListResponse<SkillVersionDTO>>;
+    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<SkillVersionDTO>>>;
     /**
      * Get a specific skill version
      */
-    getVersion(id: string, versionId: string): Promise<SkillVersionDTO>;
+    getVersion(id: string, versionId: string): Promise<Response<SkillVersionDTO>>;
     /**
      * Download a skill
      */
-    download(namespace: string, name: string): Promise<unknown>;
+    download(namespace: string, name: string): Promise<Response<unknown>>;
     /**
      * Get skill content
      */
-    getContent(namespace: string, name: string): Promise<unknown>;
+    getContent(namespace: string, name: string): Promise<Response<unknown>>;
     /**
      * Transfer ownership
      */
-    transferOwnership(id: string, newTeamId: string): Promise<SkillDTO>;
+    transferOwnership(id: string, newTeamId: string): Promise<Response<SkillDTO>>;
     /**
      * Update visibility
      */
-    updateVisibility(id: string, visibility: string): Promise<SkillDTO>;
+    updateVisibility(id: string, visibility: string): Promise<Response<SkillDTO>>;
     /**
      * List skills in the public store
      */
-    listStore(params?: Partial<CursorListRequest>): Promise<CursorListResponse<PublicSkillStoreDTO>>;
+    listStore(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<PublicSkillStoreDTO>>>;
 }

package/dist/api/mcp-servers.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { MCPServerDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * MCP Servers API
@@ -9,37 +10,37 @@ export declare class MCPServersAPI {
     /**
      * List public MCP servers
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<MCPServerDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<MCPServerDTO>>>;
     /**
      * Get an MCP server by slug
      */
-    get(slug: string): Promise<MCPServerDTO>;
+    get(slug: string): Promise<Response<MCPServerDTO>>;
     /**
      * List tools for an MCP server
      */
-    listTools(slug: string): Promise<unknown[]>;
+    listTools(slug: string): Promise<Response<unknown[]>>;
     /**
      * Call a tool on an MCP server
      */
-    callTool(slug: string, tool: string, input: unknown): Promise<unknown>;
+    callTool(slug: string, tool: string, input: unknown): Promise<Response<unknown>>;
     /**
      * List user's own MCP servers
      */
-    listOwned(params?: Partial<CursorListRequest>): Promise<CursorListResponse<MCPServerDTO>>;
+    listOwned(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<MCPServerDTO>>>;
     /**
      * Get a user's MCP server by ID
      */
-    getOwned(id: string): Promise<MCPServerDTO>;
+    getOwned(id: string): Promise<Response<MCPServerDTO>>;
     /**
      * Create an MCP server
      */
-    create(data: Partial<MCPServerDTO>): Promise<MCPServerDTO>;
+    create(data: Partial<MCPServerDTO>): Promise<Response<MCPServerDTO>>;
     /**
      * Update an MCP server
      */
-    update(id: string, data: Partial<MCPServerDTO>): Promise<MCPServerDTO>;
+    update(id: string, data: Partial<MCPServerDTO>): Promise<Response<MCPServerDTO>>;
     /**
      * Delete an MCP server
      */
-    delete(id: string): Promise<void>;
+    delete(id: string): Promise<Response<void>>;
 }

package/dist/api/projects.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { ProjectDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Projects API
@@ -9,21 +10,21 @@ export declare class ProjectsAPI {
     /**
      * List projects with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<ProjectDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<ProjectDTO>>>;
     /**
      * Get a project by ID
      */
-    get(id: string): Promise<ProjectDTO>;
+    get(id: string): Promise<Response<ProjectDTO>>;
     /**
      * Create a project
      */
-    create(data: Partial<ProjectDTO>): Promise<ProjectDTO>;
+    create(data: Partial<ProjectDTO>): Promise<Response<ProjectDTO>>;
     /**
      * Update a project
      */
-    update(id: string, data: Partial<ProjectDTO>): Promise<ProjectDTO>;
+    update(id: string, data: Partial<ProjectDTO>): Promise<Response<ProjectDTO>>;
     /**
      * Delete a project
      */
-    delete(id: string): Promise<void>;
+    delete(id: string): Promise<Response<void>>;
 }

package/dist/api/search.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { SuggestRequest, SuggestResponse } from '../types';
 /**
  * Search API
@@ -9,7 +10,7 @@ export declare class SearchAPI {
     /**
      * Unified search across skills, knowledge, and apps
      */
-    suggest(params: Partial<SuggestRequest>): Promise<SuggestResponse>;
+    suggest(params: Partial<SuggestRequest>): Promise<Response<SuggestResponse>>;
     /**
      * Full-text search via Meilisearch
      */
@@ -17,5 +18,5 @@ export declare class SearchAPI {
         q: string;
         type?: string;
         limit?: number;
-    }): Promise<unknown>;
+    }): Promise<Response<unknown>>;
 }

package/dist/api/secrets.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { SecretDTO, SecretCreateRequest, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Secrets API
@@ -9,21 +10,21 @@ export declare class SecretsAPI {
     /**
      * List secrets with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<SecretDTO>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<SecretDTO>>>;
     /**
      * Create a secret
      */
-    create(data: SecretCreateRequest): Promise<SecretDTO>;
+    create(data: SecretCreateRequest): Promise<Response<SecretDTO>>;
     /**
      * Update a secret
      */
-    update(key: string, data: Partial<SecretCreateRequest>): Promise<SecretDTO>;
+    update(key: string, data: Partial<SecretCreateRequest>): Promise<Response<SecretDTO>>;
     /**
      * Delete a secret
      */
-    delete(key: string): Promise<void>;
+    delete(key: string): Promise<Response<void>>;
     /**
      * Reveal a secret value
      */
-    reveal(key: string): Promise<SecretDTO>;
+    reveal(key: string): Promise<Response<SecretDTO>>;
 }

package/dist/api/sessions.d.ts

@@ -2,6 +2,7 @@
  * Sessions API - namespaced session operations.
  */
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { AppSessionDTO } from '../types';
 /**
  * Sessions API for managing stateful worker leases.
@@ -35,13 +36,13 @@ export declare class SessionsAPI {
      * @returns Session information
      * @throws SessionNotFoundError if session doesn't exist
      */
-    get(sessionId: string): Promise<AppSessionDTO>;
+    get(sessionId: string): Promise<Response<AppSessionDTO>>;
     /**
      * List all sessions for the current user/team.
      *
      * @returns List of session information
      */
-    list(): Promise<AppSessionDTO[]>;
+    list(): Promise<Response<AppSessionDTO[]>>;
     /**
      * Extend session expiration time.
      *
@@ -53,14 +54,14 @@ export declare class SessionsAPI {
      * @throws SessionExpiredError if session has expired
      * @throws SessionEndedError if session was ended
      */
-    keepalive(sessionId: string): Promise<AppSessionDTO>;
+    keepalive(sessionId: string): Promise<Response<AppSessionDTO>>;
     /**
      * End a session and release the worker.
      *
      * @param sessionId - The session ID
      * @throws SessionNotFoundError if session doesn't exist
      */
-    end(sessionId: string): Promise<void>;
+    end(sessionId: string): Promise<Response<void>>;
 }
 /**
  * Create a new SessionsAPI instance.

package/dist/api/sessions.js

@@ -43,8 +43,7 @@ export class SessionsAPI {
      * @returns List of session information
      */
     async list() {
-        const data = await this.http.request('get', '/sessions');
-        return data || [];
+        return this.http.request('get', '/sessions');
     }
     /**
      * Extend session expiration time.
@@ -67,7 +66,7 @@ export class SessionsAPI {
      * @throws SessionNotFoundError if session doesn't exist
      */
     async end(sessionId) {
-        await this.http.request('delete', `/sessions/${sessionId}`);
+        return this.http.request('delete', `/sessions/${sessionId}`);
     }
 }
 /**