openmates 0.15.0-alpha.21 → 0.15.0-alpha.22

package/dist/{chunk-GTFUGLRD.js → chunk-47BFVCB4.js}

@@ -14601,6 +14601,110 @@ var OpenMatesTasks = class {
     this.client = client;
   }
   async list(filters = {}) {
+    return (await this.listInternal(filters)).map(toPublicTask);
+  }
+  async listDecrypted(filters = {}) {
+    return this.list(filters);
+  }
+  async show(id, filters = {}) {
+    return toPublicTask(await this.resolve(id, filters));
+  }
+  async create(input) {
+    const masterKey = await this.client.masterKey();
+    const created = await this.createRaw(await buildCreateUserTaskInput(masterKey, input));
+    return toPublicTask(await decryptUserTask(created, masterKey));
+  }
+  async update(id, input, filters = {}) {
+    let task = await this.resolve(id, filters);
+    const masterKey = await this.client.masterKey();
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const updated = await this.updateRaw(task.taskId, await buildUpdateUserTaskInput(task, masterKey, input));
+        return toPublicTask(await decryptUserTask(updated, masterKey));
+      } catch (error) {
+        if (attempt > 0 || !isTaskVersionConflict(error)) throw error;
+        await delay(1e3);
+        task = await this.resolve(id, filters);
+      }
+    }
+    throw new OpenMatesConfigError("Task update retry failed unexpectedly");
+  }
+  async edit(id, input, filters = {}) {
+    return this.update(id, input, filters);
+  }
+  async start(id, filters = {}) {
+    let task = await this.resolve(id, filters);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const started = await this.startAIRaw(task.taskId, {
+          version: task.version,
+          primary_chat_id: task.primaryChatId ?? void 0,
+          linked_project_ids: task.linkedProjectIds,
+          plaintext_title: task.title,
+          plaintext_description: task.description,
+          plaintext_latest_instruction: task.latestInstruction
+        });
+        return toPublicTask(await decryptUserTask(started, await this.client.masterKey()));
+      } catch (error) {
+        if (attempt > 0 || !isTaskVersionConflict(error)) throw error;
+        await delay(1e3);
+        task = await this.resolve(id, filters);
+      }
+    }
+    throw new OpenMatesConfigError("Task start retry failed unexpectedly");
+  }
+  async startAI(id, filters = {}) {
+    return this.start(id, filters);
+  }
+  async delete(id, options = {}) {
+    requireConfirmed(options, "Deleting a task");
+    let task = await this.resolve(id, options.filters ?? {});
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        return await this.client.delete(`/v1/user-tasks/${encodeURIComponent(task.taskId)}?version=${encodeURIComponent(String(task.version))}`);
+      } catch (error) {
+        if (attempt > 0 || !isTaskVersionConflict(error)) throw error;
+        await delay(1e3);
+        task = await this.resolve(id, options.filters ?? {});
+      }
+    }
+    throw new OpenMatesConfigError("Task delete retry failed unexpectedly");
+  }
+  async done(id, filters = {}) {
+    return this.actionById(id, "complete", {}, filters);
+  }
+  async complete(id, filters = {}) {
+    return this.done(id, filters);
+  }
+  async block(id, reason, filters = {}) {
+    return this.actionById(id, "block", { blocked_reason_code: reason }, filters);
+  }
+  async unblock(id, filters = {}) {
+    return this.actionById(id, "unblock", {}, filters);
+  }
+  async skip(id, filters = {}) {
+    return this.actionById(id, "skip", {}, filters);
+  }
+  async reorder(id, move, filters = {}) {
+    let task = await this.resolve(id, filters);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const response = await this.client.request("/v1/user-tasks/reorder", {
+          moves: [{ ...move, task_id: task.taskId, version: task.version }]
+        });
+        return (await decryptUserTasks(response.tasks ?? [], await this.client.masterKey())).map(toPublicTask);
+      } catch (error) {
+        if (attempt > 0 || !isTaskVersionConflict(error)) throw error;
+        await delay(1e3);
+        task = await this.resolve(id, filters);
+      }
+    }
+    throw new OpenMatesConfigError("Task reorder retry failed unexpectedly");
+  }
+  async move(id, move, filters = {}) {
+    return this.reorder(id, move, filters);
+  }
+  async listRaw(filters = {}) {
     const response = await this.client.get(withQuery("/v1/user-tasks", {
       status: filters.status,
       chat_id: filters.chatId,
@@ -14608,22 +14712,57 @@ var OpenMatesTasks = class {
     }));
     return response.tasks ?? [];
   }
-  async create(input) {
+  async createRaw(input) {
     const response = await this.client.request("/v1/user-tasks", input);
     if (!response.task) throw new OpenMatesApiError(500, { detail: "User task response missing task" });
     return response.task;
   }
-  async update(taskId, input) {
+  async updateRaw(taskId, input) {
     const response = await this.client.patch(`/v1/user-tasks/${encodeURIComponent(taskId)}`, input);
     if (!response.task) throw new OpenMatesApiError(500, { detail: "User task response missing task" });
     return response.task;
   }
-  async startAI(taskId, input) {
+  async startAIRaw(taskId, input) {
     const response = await this.client.request(`/v1/user-tasks/${encodeURIComponent(taskId)}/start-ai`, input);
     if (!response.task) throw new OpenMatesApiError(500, { detail: "User task response missing task" });
     return response.task;
   }
+  async listInternal(filters) {
+    return decryptUserTasks(await this.listRaw(filters), await this.client.masterKey());
+  }
+  async resolve(id, filters) {
+    return findTask(await this.listInternal(filters), id);
+  }
+  async actionRaw(taskId, action, input) {
+    const response = await this.client.request(`/v1/user-tasks/${encodeURIComponent(taskId)}/${encodeURIComponent(action)}`, input);
+    if (!response.task) throw new OpenMatesApiError(500, { detail: "User task response missing task" });
+    return response.task;
+  }
+  async actionById(id, action, patch, filters) {
+    let task = await this.resolve(id, filters);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        const updated = await this.actionRaw(task.taskId, action, { version: task.version, ...patch });
+        return toPublicTask(await decryptUserTask(updated, await this.client.masterKey()));
+      } catch (error) {
+        if (attempt > 0 || !isTaskVersionConflict(error)) throw error;
+        await delay(1e3);
+        task = await this.resolve(id, filters);
+      }
+    }
+    throw new OpenMatesConfigError("Task action retry failed unexpectedly");
+  }
 };
+function toPublicTask(task) {
+  const { encrypted: _encrypted, ...publicTask } = task;
+  return publicTask;
+}
+function isTaskVersionConflict(error) {
+  return error instanceof OpenMatesApiError && error.status === 409 && String(JSON.stringify(error.data)).includes("TASK_VERSION_CONFLICT");
+}
+function delay(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
 var OpenMatesPlans = class {
   client;
   constructor(client) {

package/dist/cli.js

@@ -2,7 +2,7 @@
 import {
   getExtForLang,
   serializeToYaml
-} from "./chunk-GTFUGLRD.js";
+} from "./chunk-47BFVCB4.js";
 import "./chunk-AXNRPVLE.js";
 export {
   getExtForLang,

package/dist/index.d.ts

@@ -4800,6 +4800,50 @@ declare class GeneratedAppSkills {
     readonly workflows: WorkflowsAppSkills;
 }
 
+interface DecryptedUserTask {
+    taskId: string;
+    source?: string;
+    shortId: string;
+    title: string;
+    description: string;
+    tags: string[];
+    latestInstruction: string;
+    status: UserTaskStatus;
+    assigneeType: UserTaskAssigneeType;
+    assigneeHash: string | null;
+    primaryChatId: string | null;
+    linkedProjectIds: string[];
+    planId: string | null;
+    dueAt: number | null;
+    priority: number;
+    position: number;
+    queueState: string;
+    blockedReasonCode: string | null;
+    aiExecutionState: string | null;
+    readOnly?: boolean;
+    version: number;
+    encrypted: UserTaskRecord;
+}
+interface TaskCreateOptions {
+    title: string;
+    description?: string;
+    status?: UserTaskStatus;
+    assign?: string;
+    chatId?: string | null;
+    projectIds?: string[];
+    planId?: string | null;
+    dueAt?: number | null;
+}
+interface TaskUpdateOptions {
+    title?: string;
+    description?: string;
+    status?: UserTaskStatus;
+    assign?: string;
+    chatId?: string | null;
+    projectIds?: string[];
+    planId?: string | null;
+}
+
 interface OpenMatesOptions {
     apiKey?: string;
     apiUrl?: string;
@@ -4913,6 +4957,14 @@ interface DraftRecord extends EncryptedDraftRecord {
     markdown: string;
     preview: string | null;
 }
+type TaskListFilters = {
+    status?: UserTaskStatus;
+    chatId?: string;
+    projectId?: string;
+};
+type TaskPlainCreateOptions = TaskCreateOptions;
+type TaskPlainUpdateOptions = TaskUpdateOptions;
+type TaskRecord = Omit<DecryptedUserTask, "encrypted">;
 interface SdkSessionResponse {
     user?: {
         id?: string;
@@ -5147,14 +5199,35 @@ declare class OpenMatesProjects {
 declare class OpenMatesTasks {
     private readonly client;
     constructor(client: OpenMates);
-    list(filters?: {
-        status?: UserTaskStatus;
-        chatId?: string;
-        projectId?: string;
-    }): Promise<UserTaskRecord[]>;
-    create(input: UserTaskCreateInput): Promise<UserTaskRecord>;
-    update(taskId: string, input: UserTaskUpdateInput): Promise<UserTaskRecord>;
-    startAI(taskId: string, input: UserTaskStartAIInput): Promise<UserTaskRecord>;
+    list(filters?: TaskListFilters): Promise<TaskRecord[]>;
+    listDecrypted(filters?: TaskListFilters): Promise<TaskRecord[]>;
+    show(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    create(input: TaskPlainCreateOptions): Promise<TaskRecord>;
+    update(id: string, input: TaskPlainUpdateOptions, filters?: TaskListFilters): Promise<TaskRecord>;
+    edit(id: string, input: TaskPlainUpdateOptions, filters?: TaskListFilters): Promise<TaskRecord>;
+    start(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    startAI(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    delete(id: string, options?: ConfirmedMutationOptions & {
+        filters?: TaskListFilters;
+    }): Promise<{
+        deleted?: boolean;
+        task_id?: string;
+    }>;
+    done(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    complete(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    block(id: string, reason: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    unblock(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    skip(id: string, filters?: TaskListFilters): Promise<TaskRecord>;
+    reorder(id: string, move: Omit<UserTaskReorderInput["moves"][number], "task_id" | "version">, filters?: TaskListFilters): Promise<TaskRecord[]>;
+    move(id: string, move: Omit<UserTaskReorderInput["moves"][number], "task_id" | "version">, filters?: TaskListFilters): Promise<TaskRecord[]>;
+    private listRaw;
+    private createRaw;
+    private updateRaw;
+    private startAIRaw;
+    private listInternal;
+    private resolve;
+    private actionRaw;
+    private actionById;
 }
 declare class OpenMatesPlans {
     private readonly client;
@@ -5324,4 +5397,4 @@ type AssistantFeedbackDecision = {
 };
 declare function buildAssistantFeedbackDecision(rating: number): AssistantFeedbackDecision;
 
-export { APP_SKILL_METADATA, ASSISTANT_FEEDBACK_REPORT_TITLE, ASSISTANT_FEEDBACK_THANKS, type ApiKeyCreateOptions, type ApiKeyCreateResult, type ApiKeyRecord, type AssistantFeedbackDecision, type AuthMethodsStatus, type AuthoritativeChatReconciliation, type BackupCodesResult, type BankTransferOrderDetails, type BankTransferStatus, type CachedChat, type CachedNewChatSuggestion, type ChatCreateOptions, type ChatListOptions, type ChatListPage, type ChatResponse, type CliSignupResult, type DecryptedDraft, type DecryptedEmbed, type DecryptedMemoryEntry, type DecryptedMessage, type DecryptedNewChatSuggestion, type DocsFile, type DocsFolder, type DocsSearchResult, type DocsTree, type DraftRecord, type EncryptedChatMetadata, type EncryptedDraft, type EncryptedDraftRecord, type FocusModeSelection, type GiftCardBankTransferStatus, INTEREST_TAG_IDS, type InterestTagId, MATE_NAMES, MEMORY_TYPE_REGISTRY, type MemoryFieldDef, type MemoryTypeDef, OpenMates, OpenMatesApiError, OpenMatesClient, type OpenMatesClientOptions, OpenMatesConfigError, type OpenMatesOptions, type OpenMatesSession, type ProjectSourceCapability, type ProjectSourceCreateInput, type ProjectSourceRecord, type ProjectSourceStatus, type ProjectSourceType, SUPPORT_URL, type SyncCache, type TopicPreferencesPayload, type TotpSetupStartResult, type WorkflowCapability, type WorkflowDetail, type WorkflowEdge, type WorkflowGraph, type WorkflowNode, type WorkflowNodeRun, type WorkflowNodeType, type WorkflowRunContentRetention, type WorkflowRunContentStorage, type WorkflowRunDetail, type WorkflowSummary, buildAssistantFeedbackDecision, defaultCloneBranchForVersion, deriveAppUrl, normalizeInterestTagIds, reconcileAuthoritativeChats, renderSupportInfo };
+export { APP_SKILL_METADATA, ASSISTANT_FEEDBACK_REPORT_TITLE, ASSISTANT_FEEDBACK_THANKS, type ApiKeyCreateOptions, type ApiKeyCreateResult, type ApiKeyRecord, type AssistantFeedbackDecision, type AuthMethodsStatus, type AuthoritativeChatReconciliation, type BackupCodesResult, type BankTransferOrderDetails, type BankTransferStatus, type CachedChat, type CachedNewChatSuggestion, type ChatCreateOptions, type ChatListOptions, type ChatListPage, type ChatResponse, type CliSignupResult, type DecryptedDraft, type DecryptedEmbed, type DecryptedMemoryEntry, type DecryptedMessage, type DecryptedNewChatSuggestion, type DecryptedUserTask, type DocsFile, type DocsFolder, type DocsSearchResult, type DocsTree, type DraftRecord, type EncryptedChatMetadata, type EncryptedDraft, type EncryptedDraftRecord, type FocusModeSelection, type GiftCardBankTransferStatus, INTEREST_TAG_IDS, type InterestTagId, MATE_NAMES, MEMORY_TYPE_REGISTRY, type MemoryFieldDef, type MemoryTypeDef, OpenMates, OpenMatesApiError, OpenMatesClient, type OpenMatesClientOptions, OpenMatesConfigError, type OpenMatesOptions, type OpenMatesSession, type ProjectSourceCapability, type ProjectSourceCreateInput, type ProjectSourceRecord, type ProjectSourceStatus, type ProjectSourceType, SUPPORT_URL, type SyncCache, type TaskListFilters, type TaskPlainCreateOptions, type TaskPlainUpdateOptions, type TaskRecord, type TopicPreferencesPayload, type TotpSetupStartResult, type WorkflowCapability, type WorkflowDetail, type WorkflowEdge, type WorkflowGraph, type WorkflowNode, type WorkflowNodeRun, type WorkflowNodeType, type WorkflowRunContentRetention, type WorkflowRunContentStorage, type WorkflowRunDetail, type WorkflowSummary, buildAssistantFeedbackDecision, defaultCloneBranchForVersion, deriveAppUrl, normalizeInterestTagIds, reconcileAuthoritativeChats, renderSupportInfo };

package/dist/index.js

@@ -18,7 +18,7 @@ import {
   reconcileAuthoritativeChats,
   renderSupportInfo,
   serializeToYaml
-} from "./chunk-GTFUGLRD.js";
+} from "./chunk-47BFVCB4.js";
 import "./chunk-AXNRPVLE.js";
 export {
   APP_SKILL_METADATA,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmates",
-  "version": "0.15.0-alpha.21",
+  "version": "0.15.0-alpha.22",
   "description": "OpenMates CLI and SDK",
   "type": "module",
   "main": "dist/index.js",