lemma-sdk 0.2.35 → 0.2.37

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { type LemmaConfig } from "./config.js";
 import { AuthManager, type AuthState, type AuthListener } from "./auth.js";
 import { AgentsNamespace } from "./namespaces/agents.js";
-import { AssistantsNamespace, ConversationsNamespace } from "./namespaces/assistants.js";
+import { ConversationsNamespace } from "./namespaces/conversations.js";
 import { DesksNamespace } from "./namespaces/desks.js";
 import { FilesNamespace } from "./namespaces/files.js";
 import { FunctionsNamespace } from "./namespaces/functions.js";
@@ -39,7 +39,6 @@ export declare class LemmaClient {
     readonly functions: FunctionsNamespace;
     readonly agents: AgentsNamespace;
     readonly tasks: TasksNamespace;
-    readonly assistants: AssistantsNamespace;
     readonly conversations: ConversationsNamespace;
     readonly workflows: WorkflowsNamespace;
     readonly desks: DesksNamespace;

package/dist/client.js

@@ -3,7 +3,7 @@ import { AuthManager } from "./auth.js";
 import { GeneratedClientAdapter } from "./generated.js";
 import { HttpClient } from "./http.js";
 import { AgentsNamespace } from "./namespaces/agents.js";
-import { AssistantsNamespace, ConversationsNamespace } from "./namespaces/assistants.js";
+import { ConversationsNamespace } from "./namespaces/conversations.js";
 import { DesksNamespace } from "./namespaces/desks.js";
 import { FilesNamespace } from "./namespaces/files.js";
 import { FunctionsNamespace } from "./namespaces/functions.js";
@@ -37,7 +37,6 @@ export class LemmaClient {
     functions;
     agents;
     tasks;
-    assistants;
     conversations;
     workflows;
     desks;
@@ -70,7 +69,6 @@ export class LemmaClient {
         this.functions = new FunctionsNamespace(this._generated, podIdFn);
         this.agents = new AgentsNamespace(this._generated, podIdFn);
         this.tasks = new TasksNamespace(this._http, podIdFn);
-        this.assistants = new AssistantsNamespace(this._http, podIdFn);
         this.conversations = new ConversationsNamespace(this._http, podIdFn);
         this.workflows = new WorkflowsNamespace(this._generated, this._http, podIdFn);
         this.desks = new DesksNamespace(this._generated, this._http, podIdFn);

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export { buildJoinedRecordsQuery, parseForeignKeyReference, } from "./datastore-
 export type { ForeignKeyReference, JoinedRecordsColumnRef, JoinedRecordsFilter, JoinedRecordsJoin, JoinedRecordsJoinCondition, JoinedRecordsOrderBy, JoinedRecordsQueryDefinition, JoinedRecordsSelectField, JoinedRecordsSource, } from "./datastore-query.js";
 export type { AgentsNamespace } from "./namespaces/agents.js";
 export type { DatastoreNamespace } from "./namespaces/datastore.js";
-export type { AssistantsNamespace, ConversationsNamespace } from "./namespaces/assistants.js";
+export type { ConversationsNamespace } from "./namespaces/conversations.js";
 export type { DesksNamespace } from "./namespaces/desks.js";
 export type { FilesNamespace } from "./namespaces/files.js";
 export type { FunctionsNamespace } from "./namespaces/functions.js";

package/dist/namespaces/agents.js

@@ -7,7 +7,7 @@ export class AgentsNamespace {
         this.podId = podId;
     }
     list(options = {}) {
-        return this.client.request(() => AgentsService.agentList(this.podId(), options.limit ?? 100, options.pageToken));
+        return this.client.request(() => AgentsService.agentList(this.podId(), options.pageToken, options.limit ?? 100));
     }
     create(payload) {
         return this.client.request(() => AgentsService.agentCreate(this.podId(), payload));

package/dist/namespaces/conversations.d.ts

@@ -0,0 +1,73 @@
+import type { HttpClient } from "../http.js";
+import type { ConversationListResponse } from "../openapi_client/models/ConversationListResponse.js";
+import type { CreateConversationRequest } from "../openapi_client/models/CreateConversationRequest.js";
+import type { SendMessageRequest } from "../openapi_client/models/SendMessageRequest.js";
+import type { UpdateConversationRequest } from "../openapi_client/models/UpdateConversationRequest.js";
+import type { AvailableModelInfo, Conversation, ConversationMessage, ConversationModel, CursorPage } from "../types.js";
+type ConversationCreateInput = CreateConversationRequest & {
+    agent_name?: string | null;
+    model?: ConversationModel | null;
+    pod_id?: string | null;
+};
+type ConversationUpdateInput = UpdateConversationRequest & {
+    model?: ConversationModel | null;
+};
+export declare class ConversationsNamespace {
+    private readonly http;
+    private readonly podId;
+    constructor(http: HttpClient, podId: () => string);
+    private resolvePodId;
+    private requirePodId;
+    list(options?: {
+        agent_name?: string | null;
+        pod_id?: string | null;
+        limit?: number;
+        page_token?: string | null;
+    }): Promise<ConversationListResponse>;
+    listByAgent(agentName: string, options?: {
+        pod_id?: string | null;
+        limit?: number;
+        page_token?: string | null;
+    }): Promise<ConversationListResponse>;
+    listModels(): Promise<{
+        items: AvailableModelInfo[];
+        limit: number;
+        next_page_token: null;
+    }>;
+    create(payload?: ConversationCreateInput): Promise<Conversation>;
+    createForAgent(agentName: string, payload?: Omit<ConversationCreateInput, "agent_name">): Promise<Conversation>;
+    get(conversationId: string, options?: {
+        pod_id?: string | null;
+    }): Promise<Conversation>;
+    update(conversationId: string, payload: ConversationUpdateInput, options?: {
+        pod_id?: string | null;
+    }): Promise<Conversation>;
+    sendMessageStream(conversationId: string, payload: SendMessageRequest, options?: {
+        pod_id?: string | null;
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    sendOrCreateMessageStream(payload: SendMessageRequest, options?: {
+        pod_id?: string | null;
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    resumeStream(conversationId: string, options?: {
+        pod_id?: string | null;
+        agent_run_id?: string | null;
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    stopRun(conversationId: string, options?: {
+        pod_id?: string | null;
+    }): Promise<Conversation>;
+    readonly messages: {
+        list: (conversationId: string, options?: {
+            limit?: number;
+            page_token?: string | null;
+            after_sequence?: number | null;
+            pod_id?: string | null;
+        }) => Promise<CursorPage<ConversationMessage>>;
+        send: (conversationId: string, payload: SendMessageRequest, options?: {
+            pod_id?: string | null;
+        }) => Promise<unknown>;
+    };
+}
+export {};

package/dist/namespaces/conversations.js

@@ -0,0 +1,174 @@
+import { AgentModelName } from "../openapi_client/models/AgentModelName.js";
+function normalizeConversation(conversation) {
+    if (!conversation)
+        return conversation;
+    const record = conversation;
+    return {
+        ...record,
+        model: record.model ?? record.model_name ?? null,
+        status: record.status ?? "waiting",
+    };
+}
+function normalizeConversationList(response) {
+    const items = (response.items ?? []).map((conversation) => normalizeConversation(conversation));
+    return {
+        ...response,
+        items,
+    };
+}
+function normalizeMessage(message) {
+    return message;
+}
+function buildModelList() {
+    return Object.values(AgentModelName).map((model) => ({
+        id: model,
+        name: model,
+    }));
+}
+export class ConversationsNamespace {
+    http;
+    podId;
+    constructor(http, podId) {
+        this.http = http;
+        this.podId = podId;
+    }
+    resolvePodId(explicitPodId) {
+        if (typeof explicitPodId === "string") {
+            return explicitPodId;
+        }
+        try {
+            return this.podId();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    requirePodId(explicitPodId) {
+        const podId = this.resolvePodId(explicitPodId);
+        if (!podId) {
+            throw new Error("pod_id is required for this conversation operation.");
+        }
+        return podId;
+    }
+    list(options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        return this.http.request("GET", `/pods/${podId}/conversations`, {
+            params: {
+                agent_name: options.agent_name,
+                limit: options.limit ?? 20,
+                page_token: options.page_token,
+            },
+        }).then(normalizeConversationList);
+    }
+    listByAgent(agentName, options = {}) {
+        return this.list({ ...options, agent_name: agentName });
+    }
+    async listModels() {
+        const items = buildModelList();
+        return {
+            items,
+            limit: items.length,
+            next_page_token: null,
+        };
+    }
+    create(payload = {}) {
+        const podId = this.requirePodId(payload.pod_id);
+        const { agent_name, model, model_name, pod_id, ...requestBody } = payload;
+        const body = {
+            ...requestBody,
+            agent_name: agent_name ?? undefined,
+            model_name: model_name ?? model,
+        };
+        void pod_id;
+        return this.http.request("POST", `/pods/${podId}/conversations`, {
+            body,
+        }).then(normalizeConversation);
+    }
+    createForAgent(agentName, payload = {}) {
+        return this.create({
+            ...payload,
+            agent_name: agentName,
+        });
+    }
+    get(conversationId, options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        return this.http.request("GET", `/pods/${podId}/conversations/${conversationId}`)
+            .then(normalizeConversation);
+    }
+    update(conversationId, payload, options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        const { model, model_name, ...requestBody } = payload;
+        const body = {
+            ...requestBody,
+            model_name: model_name ?? model,
+        };
+        return this.http.request("PATCH", `/pods/${podId}/conversations/${conversationId}`, {
+            body,
+        }).then(normalizeConversation);
+    }
+    sendMessageStream(conversationId, payload, options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        return this.http.stream(`/pods/${podId}/conversations/${conversationId}/messages`, {
+            method: "POST",
+            body: payload,
+            signal: options.signal,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            },
+        });
+    }
+    sendOrCreateMessageStream(payload, options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        return this.http.stream(`/pods/${podId}/conversations/messages`, {
+            method: "POST",
+            body: payload,
+            signal: options.signal,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            },
+        });
+    }
+    resumeStream(conversationId, options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        return this.http.stream(`/pods/${podId}/conversations/${conversationId}/stream`, {
+            params: {
+                agent_run_id: options.agent_run_id,
+            },
+            signal: options.signal,
+            headers: {
+                Accept: "text/event-stream",
+            },
+        });
+    }
+    stopRun(conversationId, options = {}) {
+        const podId = this.requirePodId(options.pod_id);
+        return this.http.request("POST", `/pods/${podId}/conversations/${conversationId}/stop`, {
+            body: {},
+        }).then(normalizeConversation);
+    }
+    messages = {
+        list: (conversationId, options = {}) => {
+            const podId = this.requirePodId(options.pod_id);
+            const parsedPageToken = typeof options.page_token === "string" && options.page_token.trim().length > 0
+                ? Number(options.page_token)
+                : null;
+            return this.http.request("GET", `/pods/${podId}/conversations/${conversationId}/messages`, {
+                params: {
+                    after_sequence: options.after_sequence ?? (Number.isFinite(parsedPageToken) ? parsedPageToken : undefined),
+                    limit: options.limit ?? 100,
+                },
+            }).then((response) => ({
+                ...response,
+                items: (response.items ?? []).map(normalizeMessage),
+            }));
+        },
+        send: (conversationId, payload, options = {}) => {
+            const podId = this.requirePodId(options.pod_id);
+            return this.http.request("POST", `/pods/${podId}/conversations/${conversationId}/messages`, {
+                body: payload,
+            });
+        },
+    };
+}

package/dist/namespaces/files.d.ts

@@ -3,6 +3,7 @@ import type { HttpClient } from "../http.js";
 import type { ConvertedFileResponse } from "../openapi_client/models/ConvertedFileResponse.js";
 import type { DirectoryTreeResponse } from "../openapi_client/models/DirectoryTreeResponse.js";
 import { SearchMethod } from "../openapi_client/models/SearchMethod.js";
+import type { DatastoreFileNamespace } from "../types.js";
 export declare class FilesNamespace {
     private readonly client;
     private readonly http;
@@ -13,17 +14,25 @@ export declare class FilesNamespace {
         pageToken?: string;
         directoryPath?: string;
         parentId?: string;
+        namespace?: DatastoreFileNamespace | null;
     }): Promise<import("../types.js").FileListResponse>;
-    get(path: string): Promise<import("../types.js").FileResponse>;
-    delete(path: string): Promise<import("../types.js").DatastoreMessageResponse>;
+    get(path: string, options?: {
+        namespace?: DatastoreFileNamespace | null;
+    }): Promise<import("../types.js").FileResponse>;
+    delete(path: string, options?: {
+        namespace?: DatastoreFileNamespace | null;
+    }): Promise<import("../types.js").DatastoreMessageResponse>;
     search(query: string, options?: {
         limit?: number;
         searchMethod?: SearchMethod;
     }): Promise<import("../types.js").FileSearchResponse>;
-    download(path: string): Promise<Blob>;
+    download(path: string, options?: {
+        namespace?: DatastoreFileNamespace | null;
+    }): Promise<Blob>;
     tree(options?: {
         rootPath?: string;
         filesPerDirectory?: number;
+        namespace?: DatastoreFileNamespace | null;
     }): Promise<DirectoryTreeResponse>;
     upload(file: Blob, options?: {
         name?: string;
@@ -31,6 +40,7 @@ export declare class FilesNamespace {
         parentId?: string;
         searchEnabled?: boolean;
         description?: string;
+        namespace?: DatastoreFileNamespace | null;
     }): Promise<import("../types.js").FileResponse>;
     update(path: string, options?: {
         file?: Blob;
@@ -40,17 +50,25 @@ export declare class FilesNamespace {
         parentId?: string;
         newPath?: string;
         searchEnabled?: boolean;
+        namespace?: DatastoreFileNamespace | null;
     }): Promise<import("../types.js").FileResponse>;
     readonly folder: {
         create: (name: string, options?: {
             directoryPath?: string;
             parentId?: string;
             description?: string;
+            namespace?: DatastoreFileNamespace | null;
         }) => Promise<import("../types.js").FileResponse>;
     };
     readonly converted: {
-        get: (path: string) => Promise<ConvertedFileResponse>;
-        render: (path: string) => Promise<string>;
-        download: (path: string, artifact?: string) => Promise<Blob>;
+        get: (path: string, options?: {
+            namespace?: DatastoreFileNamespace | null;
+        }) => Promise<ConvertedFileResponse>;
+        render: (path: string, options?: {
+            namespace?: DatastoreFileNamespace | null;
+        }) => Promise<string>;
+        download: (path: string, artifact?: string, options?: {
+            namespace?: DatastoreFileNamespace | null;
+        }) => Promise<Blob>;
     };
 }

package/dist/namespaces/files.js

@@ -1,3 +1,4 @@
+import { FileNamespace } from "../openapi_client/models/FileNamespace.js";
 import { SearchMethod } from "../openapi_client/models/SearchMethod.js";
 import { FilesService } from "../openapi_client/services/FilesService.js";
 function joinDatastorePath(basePath, leaf) {
@@ -29,6 +30,13 @@ function getBaseName(path) {
     }
     return normalized.slice(index + 1);
 }
+function normalizeFileNamespace(namespace) {
+    const normalized = String(namespace ?? "").trim().toUpperCase();
+    if (normalized === FileNamespace.PERSONAL || normalized === "PRIVATE") {
+        return FileNamespace.PERSONAL;
+    }
+    return FileNamespace.POD;
+}
 export class FilesNamespace {
     client;
     http;
@@ -40,13 +48,13 @@ export class FilesNamespace {
     }
     list(options = {}) {
         const directoryPath = options.directoryPath ?? options.parentId ?? "/";
-        return this.client.request(() => FilesService.fileList(this.podId(), directoryPath, options.limit ?? 100, options.pageToken));
+        return this.client.request(() => FilesService.fileList(this.podId(), directoryPath, normalizeFileNamespace(options.namespace), options.limit ?? 100, options.pageToken));
     }
-    get(path) {
-        return this.client.request(() => FilesService.fileGet(this.podId(), path));
+    get(path, options = {}) {
+        return this.client.request(() => FilesService.fileGet(this.podId(), path, normalizeFileNamespace(options.namespace)));
     }
-    delete(path) {
-        return this.client.request(() => FilesService.fileDelete(this.podId(), path));
+    delete(path, options = {}) {
+        return this.client.request(() => FilesService.fileDelete(this.podId(), path, normalizeFileNamespace(options.namespace)));
     }
     search(query, options = {}) {
         return this.client.request(() => FilesService.fileSearch(this.podId(), {
@@ -55,12 +63,13 @@ export class FilesNamespace {
             search_method: options.searchMethod ?? SearchMethod.HYBRID,
         }));
     }
-    download(path) {
+    download(path, options = {}) {
         const encodedPath = encodeURIComponent(path);
-        return this.http.requestBytes("GET", `/pods/${this.podId()}/datastore/files/download?path=${encodedPath}`);
+        const encodedNamespace = encodeURIComponent(normalizeFileNamespace(options.namespace));
+        return this.http.requestBytes("GET", `/pods/${this.podId()}/datastore/files/download?path=${encodedPath}&namespace=${encodedNamespace}`);
     }
     tree(options = {}) {
-        return this.client.request(() => FilesService.fileTree(this.podId(), options.rootPath ?? "/", options.filesPerDirectory ?? 3));
+        return this.client.request(() => FilesService.fileTree(this.podId(), options.rootPath ?? "/", normalizeFileNamespace(options.namespace), options.filesPerDirectory ?? 3));
     }
     upload(file, options = {}) {
         const payload = {
@@ -69,6 +78,7 @@ export class FilesNamespace {
             description: options.description,
             directory_path: options.directoryPath ?? options.parentId ?? "/",
             search_enabled: options.searchEnabled ?? true,
+            namespace: normalizeFileNamespace(options.namespace),
         };
         return this.client.request(() => FilesService.fileUpload(this.podId(), payload));
     }
@@ -87,6 +97,7 @@ export class FilesNamespace {
             description: options.description,
             new_path: resolvedNewPath,
             search_enabled: options.searchEnabled,
+            namespace: normalizeFileNamespace(options.namespace),
         };
         return this.client.request(() => FilesService.fileUpdate(this.podId(), payload));
     }
@@ -95,17 +106,19 @@ export class FilesNamespace {
             const payload = {
                 path: joinDatastorePath(options.directoryPath ?? options.parentId, name),
                 description: options.description,
+                namespace: normalizeFileNamespace(options.namespace),
             };
             return this.client.request(() => FilesService.fileFolderCreate(this.podId(), payload));
         },
     };
     converted = {
-        get: (path) => this.client.request(() => FilesService.fileConvertedGet(this.podId(), path)),
-        render: (path) => this.client.request(() => FilesService.fileConvertedRender(this.podId(), path)),
-        download: (path, artifact = "document.md") => {
+        get: (path, options = {}) => this.client.request(() => FilesService.fileConvertedGet(this.podId(), path, normalizeFileNamespace(options.namespace))),
+        render: (path, options = {}) => this.client.request(() => FilesService.fileConvertedRender(this.podId(), path, normalizeFileNamespace(options.namespace))),
+        download: (path, artifact = "document.md", options = {}) => {
             const encodedPath = encodeURIComponent(path);
             const encodedArtifact = encodeURIComponent(artifact);
-            return this.http.requestBytes("GET", `/pods/${this.podId()}/datastore/files/converted/download?path=${encodedPath}&artifact=${encodedArtifact}`);
+            const encodedNamespace = encodeURIComponent(normalizeFileNamespace(options.namespace));
+            return this.http.requestBytes("GET", `/pods/${this.podId()}/datastore/files/converted/download?path=${encodedPath}&artifact=${encodedArtifact}&namespace=${encodedNamespace}`);
         },
     };
 }

package/dist/namespaces/integrations.d.ts

@@ -8,11 +8,19 @@ export declare class IntegrationsNamespace {
     }): Promise<import("../types.js").ApplicationListResponseSchema>;
     get(applicationId: string): Promise<import("../types.js").ApplicationDetailResponseSchema>;
     readonly operations: {
-        list: (applicationId: string) => Promise<import("../types.js").OperationListResponse>;
+        discover: (applicationId: string, options?: {
+            query?: string;
+            limit?: number;
+        }) => Promise<import("../types.js").OperationDiscoverResponse>;
+        list: (applicationId: string, options?: {
+            query?: string;
+            limit?: number;
+        }) => Promise<import("../types.js").OperationSummary[]>;
         get: (applicationId: string, operationName: string) => Promise<import("../types.js").OperationDetail>;
+        details: (applicationId: string, operationNames?: string[]) => Promise<import("../types.js").OperationDetailsBatchResponse>;
         execute: (applicationId: string, operationName: string, payload: Record<string, unknown>, accountId?: string) => Promise<import("../types.js").OperationExecutionResponse>;
-        descriptor: (applicationId: string) => Promise<import("../types.js").AppDescriptorResponse>;
     };
+    helperAgent(goal: string, appNames: string[]): Promise<import("../types.js").IntegrationHelperAgentResponse>;
     readonly triggers: {
         list: (options?: {
             applicationId?: string;

package/dist/namespaces/integrations.js

@@ -1,3 +1,4 @@
+import { AgentToolsService } from "../openapi_client/services/AgentToolsService.js";
 import { ApplicationsService } from "../openapi_client/services/ApplicationsService.js";
 import { IntegrationsService } from "../openapi_client/services/IntegrationsService.js";
 export class IntegrationsNamespace {
@@ -12,14 +13,28 @@ export class IntegrationsNamespace {
         return this.client.request(() => ApplicationsService.applicationGet(applicationId));
     }
     operations = {
-        list: (applicationId) => this.client.request(() => ApplicationsService.applicationOperationList(applicationId)),
+        discover: (applicationId, options = {}) => this.client.request(() => ApplicationsService.applicationOperationDiscover(applicationId, options.query, options.limit ?? 100)),
+        list: async (applicationId, options = {}) => {
+            const response = await this.client.request(() => ApplicationsService.applicationOperationDiscover(applicationId, options.query, options.limit ?? 100));
+            return response.items ?? [];
+        },
         get: (applicationId, operationName) => this.client.request(() => ApplicationsService.applicationOperationDetail(applicationId, operationName)),
+        details: (applicationId, operationNames) => {
+            const body = { operation_names: operationNames };
+            return this.client.request(() => ApplicationsService.applicationOperationDetailsBatch(applicationId, body));
+        },
         execute: (applicationId, operationName, payload, accountId) => {
             const body = { payload, account_id: accountId };
             return this.client.request(() => ApplicationsService.applicationOperationExecute(applicationId, operationName, body));
         },
-        descriptor: (applicationId) => this.client.request(() => ApplicationsService.applicationDescriptor(applicationId)),
     };
+    helperAgent(goal, appNames) {
+        const body = {
+            app_names: appNames,
+            goal,
+        };
+        return this.client.request(() => AgentToolsService.agentToolIntegrationHelperAgent(body));
+    }
     triggers = {
         list: (options = {}) => this.client.request(() => ApplicationsService.applicationTriggerList(options.applicationId, options.search, options.limit ?? 100, options.pageToken)),
         get: (triggerId) => this.client.request(() => ApplicationsService.applicationTriggerGet(triggerId)),

package/dist/namespaces/pod-surfaces.d.ts

@@ -8,7 +8,7 @@ export declare class PodSurfacesNamespace {
         limit?: number;
         pageToken?: string;
         cursor?: string;
-    }): Promise<import("../types.js").AssistantSurfaceListResponse>;
+    }): Promise<import("../types.js").AgentSurfaceListResponse>;
     create(podId: string, payload: CreateSurfaceRequest): Promise<any>;
     get(podId: string, surfaceId: string): Promise<any>;
     updateConfig(podId: string, surfaceId: string, payload: UpdateSurfaceRequest): Promise<any>;

package/dist/namespaces/pod-surfaces.js

@@ -1,22 +1,22 @@
-import { AssistantSurfacesService } from "../openapi_client/services/AssistantSurfacesService.js";
+import { AgentSurfacesService } from "../openapi_client/services/AgentSurfacesService.js";
 export class PodSurfacesNamespace {
     client;
     constructor(client) {
         this.client = client;
     }
     list(podId, options = {}) {
-        return this.client.request(() => AssistantSurfacesService.assistantSurfaceList(podId, options.limit ?? 100, options.pageToken ?? options.cursor));
+        return this.client.request(() => AgentSurfacesService.agentSurfaceList(podId, options.limit ?? 100, options.pageToken ?? options.cursor));
     }
     create(podId, payload) {
-        return this.client.request(() => AssistantSurfacesService.assistantSurfaceCreate(podId, payload));
+        return this.client.request(() => AgentSurfacesService.agentSurfaceCreate(podId, payload));
     }
     get(podId, surfaceId) {
-        return this.client.request(() => AssistantSurfacesService.assistantSurfaceGet(podId, surfaceId));
+        return this.client.request(() => AgentSurfacesService.agentSurfaceGet(podId, surfaceId));
     }
     updateConfig(podId, surfaceId, payload) {
-        return this.client.request(() => AssistantSurfacesService.assistantSurfaceUpdate(podId, surfaceId, payload));
+        return this.client.request(() => AgentSurfacesService.agentSurfaceUpdate(podId, surfaceId, payload));
     }
     toggle(podId, surfaceId, isActive) {
-        return this.client.request(() => AssistantSurfacesService.assistantSurfaceToggle(podId, surfaceId, { is_active: isActive }));
+        return this.client.request(() => AgentSurfacesService.agentSurfaceToggle(podId, surfaceId, { is_active: isActive }));
     }
 }

package/dist/namespaces/tasks.d.ts

@@ -1,9 +1,5 @@
 import type { HttpClient } from "../http.js";
-import type { AddMessageRequest } from "../openapi_client/models/AddMessageRequest.js";
-import type { CreateTaskRequest } from "../openapi_client/models/CreateTaskRequest.js";
-import type { TaskListResponse } from "../openapi_client/models/TaskListResponse.js";
-import type { TaskMessageListResponse } from "../openapi_client/models/TaskMessageListResponse.js";
-import type { TaskResponse } from "../openapi_client/models/TaskResponse.js";
+import type { AddMessageRequest, CreateTaskRequest, TaskListResponse, TaskMessageListResponse, TaskResponse } from "../types.js";
 export declare class TasksNamespace {
     private readonly http;
     private readonly podId;