@prismer/sdk 1.8.2 → 1.9.6

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/cli.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -1772,6 +1773,23 @@ var AccountClient = class {
   async refreshToken() {
     return this._r("POST", "/api/im/token/refresh");
   }
+  /**
+   * List agents owned by the current human user (v1.9.3).
+   * Mobile clients call this on launch to populate the Profile/agent runtime card.
+   * Returns `[]` for non-human / api-key-proxy callers without a cloudUserId.
+   */
+  async listAgents() {
+    return this._r("GET", "/api/im/me/agents");
+  }
+  /**
+   * Self-service account deletion (v1.9.3).
+   * Soft-deletes the IMUser, cascades owned conversations + open tasks,
+   * revokes pc_api_keys, and blacklists the request token.
+   * The caller can only delete themselves — there is no target id parameter.
+   */
+  async deleteAccount() {
+    return this._r("DELETE", "/api/im/me");
+  }
 };
 var DirectClient = class {
   constructor(_r) {
@@ -2094,6 +2112,9 @@ var TasksClient = class {
   /** List tasks with optional filters */
   async list(options) {
     const query = {};
+    query.view = options?.view ?? "board";
+    if (options?.kind) query.kind = options.kind;
+    if (!options?.kind && query.view === "board") query.kind = "work_item,goal";
     if (options?.status) query.status = options.status;
     if (options?.capability) query.capability = options.capability;
     if (options?.assigneeId) query.assigneeId = options.assigneeId;
@@ -2101,12 +2122,38 @@ var TasksClient = class {
     if (options?.scheduleType) query.scheduleType = options.scheduleType;
     if (options?.limit != null) query.limit = String(options.limit);
     if (options?.cursor) query.cursor = options.cursor;
+    if (options?.workspaceId) query.workspaceId = options.workspaceId;
+    if (options?.conversationId) query.conversationId = options.conversationId;
     return this._r("GET", "/api/im/tasks", void 0, query);
   }
   /** Get task details with logs */
   async get(taskId) {
     return this._r("GET", `/api/im/tasks/${taskId}`);
   }
+  /**
+   * Wave-9 (v1.9.4) — fetch the canonical task result.
+   *
+   * Replaces the legacy "list IMAssets where kind=task-result + sourceTaskId"
+   * pattern. Returns the locked shape defined by `IMTaskResult`; in
+   * particular `assetIds` is always an array (possibly empty) so callers
+   * can iterate without a null-check.
+   *
+   * Access: creator, assignee, or marketplace visibility on the task.
+   */
+  async getResult(taskId) {
+    return this._r("GET", `/api/im/tasks/${taskId}/result`);
+  }
+  /**
+   * Wave-9 (v1.9.4) — fetch the canonical run result.
+   *
+   * Same shape as `getResult` but reads from IMTaskRun.output instead of
+   * IMTask.result. Use this for chat-mention dispatches whose result lives
+   * on a run row rather than a board task. The `taskId` field of the
+   * returned object is the run.id.
+   */
+  async getRunResult(runId) {
+    return this._r("GET", `/api/im/runs/${runId}/result`);
+  }
   /** Update a task */
   async update(taskId, options) {
     return this._r("PATCH", `/api/im/tasks/${taskId}`, options);
@@ -2185,6 +2232,18 @@ var MemoryClient = class {
   async getKnowledgeLinks() {
     return this._r("GET", "/api/im/memory/links");
   }
+  /**
+   * Get a CC-style always-load digest of all memory files (v1.9.3).
+   * The digest is a Markdown bundle suitable for prepending to LLM context.
+   * Server clamps `maxLines` to 10–1000 and `maxBytes` to 500–30000.
+   */
+  async digest(options) {
+    const query = {};
+    if (options?.scope) query.scope = options.scope;
+    if (options?.maxLines != null) query.maxLines = String(options.maxLines);
+    if (options?.maxBytes != null) query.maxBytes = String(options.maxBytes);
+    return this._r("GET", "/api/im/memory/digest", void 0, query);
+  }
 };
 var KnowledgeLinkClient = class {
   constructor(_r) {
@@ -2722,6 +2781,226 @@ var EvolutionClient = class {
 function safeSlug(input) {
   return input.replace(/[\/\\]/g, "").replace(/\.\./g, "").replace(/\0/g, "");
 }
+var WorkspacesClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List active workspaces owned by the caller. */
+  async list() {
+    return this._r("GET", "/api/im/workspaces");
+  }
+  /**
+   * Create a workspace. In 1.9.x most callers don't need this — registration
+   * auto-creates a default workspace. The first workspace per owner is
+   * always default; subsequent ones must omit `isDefault` (server returns 409).
+   */
+  async create(options) {
+    return this._r("POST", "/api/im/workspaces", options);
+  }
+  /** Daemon delta-sync workspaces since an ISO timestamp. */
+  async sync(since) {
+    const query = {};
+    if (since) query.since = since;
+    return this._r("GET", "/api/im/workspaces/sync", void 0, query);
+  }
+  /** Get a single workspace by id (caller must own). */
+  async get(workspaceId) {
+    return this._r("GET", `/api/im/workspaces/${workspaceId}`);
+  }
+  /** Update workspace name and/or metadata. `slug` and `isDefault` are immutable in 1.9.x. */
+  async update(workspaceId, options) {
+    return this._r("PATCH", `/api/im/workspaces/${workspaceId}`, options);
+  }
+  /**
+   * Archive (delete) a workspace. Server returns 405 in 1.9.x — workspace
+   * deletion equals account close, which goes through `account.deleteAccount()`.
+   * Provided for forward-compat; will become real in 1.10+.
+   */
+  async archive(workspaceId) {
+    return this._r("DELETE", `/api/im/workspaces/${workspaceId}`);
+  }
+};
+var WorkspaceFilesClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List the active file tree for a workspace, or look up a single file by path. */
+  async list(workspaceId, options) {
+    const query = {};
+    if (options?.path) query.path = options.path;
+    return this._r("GET", `/api/im/workspaces/${workspaceId}/files`, void 0, query);
+  }
+  /**
+   * Bind `path → assetId`. Idempotent if `(path, assetId)` matches the existing
+   * active binding. Asset must already exist in the same workspace.
+   */
+  async create(workspaceId, options) {
+    return this._r("POST", `/api/im/workspaces/${workspaceId}/files`, options);
+  }
+  /** Soft-delete the active binding at `path`. */
+  async delete(workspaceId, path4) {
+    return this._r("DELETE", `/api/im/workspaces/${workspaceId}/files`, void 0, { path: path4 });
+  }
+  /** Daemon delta-sync workspace files since an ISO timestamp. */
+  async sync(workspaceId, since) {
+    const query = {};
+    if (since) query.since = since;
+    return this._r("GET", `/api/im/workspaces/${workspaceId}/files/sync`, void 0, query);
+  }
+  /** Get the version chain for a file (walks `parentVersionId`). */
+  async history(workspaceId, fileId) {
+    return this._r("GET", `/api/im/workspaces/${workspaceId}/files/${fileId}/history`);
+  }
+};
+var AssetsClient = class {
+  constructor(_r, _baseUrl, _fetchFn, _getAuthHeaders) {
+    this._r = _r;
+    this._baseUrl = _baseUrl;
+    this._fetchFn = _fetchFn;
+    this._getAuthHeaders = _getAuthHeaders;
+  }
+  /** List assets in a workspace (filterable by task and kind). */
+  async list(options) {
+    const query = {};
+    if (options.workspaceId) query.workspaceId = options.workspaceId;
+    if (options.taskId) query.taskId = options.taskId;
+    if (options.kind) query.kind = options.kind;
+    if (options.limit != null) query.limit = String(options.limit);
+    return this._r("GET", "/api/im/assets", void 0, query);
+  }
+  /**
+   * Look up an asset by content hash within a workspace. Useful for dedupe
+   * checks ("do I already have this file?") before uploading.
+   */
+  async byHash(hash, workspaceId) {
+    return this._r("GET", `/api/im/assets/by-hash/${encodeURIComponent(hash)}`, void 0, { wsId: workspaceId });
+  }
+  /**
+   * Get full asset metadata + a freshly-signed URL (5 min TTL, S3 backend only).
+   * For `kind === 'photo-memory-segment'` this also includes a `photoRefs`
+   * reverse-lookup of memory references.
+   */
+  async detail(assetId) {
+    return this._r("GET", `/api/im/assets/${assetId}/detail`);
+  }
+  /**
+   * Soft-delete an asset (the underlying S3 object is retained). Idempotent.
+   */
+  async delete(assetId) {
+    return this._r("DELETE", `/api/im/assets/${assetId}`);
+  }
+  /**
+   * Build a download URL for an asset. Filesystem backend streams bytes
+   * directly; S3 backend returns a 302 to a 5-minute presigned URL.
+   * Use `download()` for a one-shot fetch returning bytes.
+   */
+  url(assetId) {
+    return `${this._baseUrl}/api/im/assets/${assetId}`;
+  }
+  /**
+   * Download an asset's bytes. Authentication is forwarded; for S3 backend
+   * the server returns a 302 which `fetch` follows automatically.
+   */
+  async download(assetId) {
+    const resp = await this._fetchFn(this.url(assetId), {
+      method: "GET",
+      headers: this._getAuthHeaders()
+    });
+    if (!resp.ok) {
+      throw new Error(`Asset download failed (${resp.status}): ${await resp.text()}`);
+    }
+    const ab = await resp.arrayBuffer();
+    const sizeHeader = resp.headers.get("content-length");
+    return {
+      bytes: new Uint8Array(ab),
+      mime: resp.headers.get("content-type"),
+      sizeBytes: sizeHeader ? Number(sizeHeader) : null
+    };
+  }
+  /**
+   * Upload bytes as an asset (multipart). 100 MB hard cap; >50 MB returns
+   * 413 with `USE_PRESIGNED` — use S3 presign flow for those (not yet wrapped).
+   */
+  async upload(input, options) {
+    let bytes;
+    let fileName;
+    if (typeof input === "string") {
+      const fs4 = await import("fs");
+      const path4 = await import("path");
+      const buf = await fs4.promises.readFile(input);
+      bytes = new Uint8Array(buf);
+      fileName = options.fileName || path4.basename(input);
+    } else if (typeof Blob !== "undefined" && input instanceof Blob) {
+      const ab2 = await input.arrayBuffer();
+      bytes = new Uint8Array(ab2);
+      fileName = options.fileName || (input instanceof File ? input.name : "");
+      if (!fileName) throw new Error("fileName is required when uploading Blob without name");
+    } else if (input instanceof Uint8Array) {
+      bytes = input;
+      fileName = options.fileName || "";
+      if (!fileName) throw new Error("fileName is required when uploading Buffer or Uint8Array");
+    } else {
+      throw new Error("Unsupported input type");
+    }
+    const mimeType = options.mimeType || guessMimeType(fileName);
+    const sizeBytes = bytes.byteLength;
+    if (sizeBytes > 100 * 1024 * 1024) {
+      throw new Error("Asset exceeds 100 MB cap");
+    }
+    const formData = new FormData();
+    const ab = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(ab).set(bytes);
+    formData.append("file", new Blob([ab], { type: mimeType }), fileName);
+    formData.append("workspaceId", options.workspaceId);
+    if (options.kind) formData.append("kind", options.kind);
+    if (options.sourceAgentImUserId) formData.append("sourceAgentImUserId", options.sourceAgentImUserId);
+    if (options.sourceTaskId) formData.append("sourceTaskId", options.sourceTaskId);
+    if (options.metadata) formData.append("metadata", JSON.stringify(options.metadata));
+    const resp = await this._fetchFn(`${this._baseUrl}/api/im/assets`, {
+      method: "POST",
+      body: formData,
+      headers: this._getAuthHeaders()
+    });
+    options.onProgress?.(sizeBytes, sizeBytes);
+    const data = await resp.json().catch(() => ({}));
+    if (!resp.ok) {
+      return {
+        ok: false,
+        error: data?.error || { code: "HTTP_ERROR", message: `Upload failed (${resp.status})` }
+      };
+    }
+    return data;
+  }
+};
+var RuntimeInstallationsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List runtime installations in a workspace. */
+  async list(workspaceId, options) {
+    const query = { workspaceId };
+    if (options?.limit != null) query.limit = String(options.limit);
+    return this._r("GET", "/api/workspace/runtime-installations", void 0, query);
+  }
+  /**
+   * Create a new runtime installation. Mints a durable runtime API key,
+   * RPCs the sandbox controller, and persists an `IMContainer` row.
+   * The daemon receives `PRISMER_API_KEY`, `PRISMER_DAEMON_ID`,
+   * `PRISMER_BASE_URL`, `PRISMER_WORKSPACE_ID`, and
+   * `PRISMER_RUNTIME_KIND=workspace-daemon` env vars.
+   */
+  async create(options) {
+    return this._r("POST", "/api/workspace/runtime-installations", options);
+  }
+  /**
+   * Install an agent onto a runtime daemon. Resolves or creates the agent
+   * profile, calls the controller's `installAgent` RPC, and stamps
+   * `IMAgentCard.metadata.daemonId` + `runtimeInstallationId`.
+   */
+  async installAgent(runtimeInstallationId, options) {
+    return this._r("POST", `/api/workspace/runtime-installations/${runtimeInstallationId}/agents`, options);
+  }
+};
 function guessMimeType(fileName) {
   const ext = fileName.split(".").pop()?.toLowerCase() || "";
   const map = {
@@ -2928,8 +3207,9 @@ var FilesClient = class {
   }
 };
 var IMRealtimeClient = class {
-  constructor(_wsBase) {
+  constructor(_wsBase, _fetchFn = fetch) {
     this._wsBase = _wsBase;
+    this._fetchFn = _fetchFn;
   }
   /** Get the WebSocket URL */
   wsUrl(token) {
@@ -2940,6 +3220,14 @@ var IMRealtimeClient = class {
   sseUrl(token) {
     return token ? `${this._wsBase}/sse?token=${token}` : `${this._wsBase}/sse`;
   }
+  /**
+   * Get the URL for the v1.8.2 task SSE stream
+   * (`GET /api/im/tasks/events?token=...`).
+   * Supports `Last-Event-ID` for replay.
+   */
+  taskEventsUrl(token) {
+    return `${this._wsBase}/api/im/tasks/events?token=${encodeURIComponent(token)}`;
+  }
   /** Create a WebSocket client. Call .connect() to establish connection. */
   connectWS(config) {
     return new RealtimeWSClient(this._wsBase, config);
@@ -2948,6 +3236,101 @@ var IMRealtimeClient = class {
   connectSSE(config) {
     return new RealtimeSSEClient(this._wsBase, config);
   }
+  /**
+   * Subscribe to the task events SSE stream (v1.8.2/v1.9.3).
+   *
+   * Resolves with a `disconnect()` function for cleanup. Emits envelopes of
+   * shape `{ id?, type, payload }` for each parsed `event:` block. Ignores
+   * comment lines (`:` heartbeats).
+   *
+   * @example
+   *   const sub = await client.im.realtime.subscribeTaskEvents(apiKey, (evt) => {
+   *     if (evt.type === 'task.completed') console.log('done:', evt.payload);
+   *   });
+   *   // ... later:
+   *   sub.disconnect();
+   */
+  async subscribeTaskEvents(token, onEvent, options) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    options?.signal?.addEventListener("abort", onAbort);
+    const headers = { Accept: "text/event-stream" };
+    if (options?.lastEventId) headers["Last-Event-ID"] = options.lastEventId;
+    const resp = await this._fetchFn(this.taskEventsUrl(token), {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+    if (!resp.ok || !resp.body) {
+      options?.signal?.removeEventListener("abort", onAbort);
+      throw new Error(`Task events SSE failed: ${resp.status}`);
+    }
+    void (async () => {
+      const reader = resp.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let pending = { data: [] };
+      const flush = () => {
+        if (!pending.type && pending.data.length === 0) return;
+        const dataStr = pending.data.join("\n");
+        let payload = {};
+        if (dataStr) {
+          try {
+            payload = JSON.parse(dataStr);
+          } catch {
+          }
+        }
+        try {
+          onEvent({
+            id: pending.id,
+            type: pending.type ?? "task.updated",
+            payload
+          });
+        } catch {
+        }
+        pending = { data: [] };
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          let lineEnd;
+          while ((lineEnd = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, lineEnd).replace(/\r$/, "");
+            buffer = buffer.slice(lineEnd + 1);
+            if (line === "") {
+              flush();
+              continue;
+            }
+            if (line.startsWith(":")) continue;
+            const colon = line.indexOf(":");
+            const field = colon === -1 ? line : line.slice(0, colon);
+            const valueStr = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+            if (field === "event") pending.type = valueStr;
+            else if (field === "id") pending.id = valueStr;
+            else if (field === "data") pending.data.push(valueStr);
+          }
+        }
+        flush();
+      } catch {
+      } finally {
+        try {
+          reader.releaseLock();
+        } catch {
+        }
+        options?.signal?.removeEventListener("abort", onAbort);
+      }
+    })();
+    return {
+      disconnect: () => {
+        try {
+          controller.abort();
+        } catch {
+        }
+      }
+    };
+  }
 };
 var IMClient = class {
   constructor(request2, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
@@ -2960,6 +3343,10 @@ var IMClient = class {
     this.bindings = new BindingsClient(request2);
     this.credits = new CreditsClient(request2);
     this.workspace = new WorkspaceClient(request2);
+    this.workspaces = new WorkspacesClient(request2);
+    this.workspaceFiles = new WorkspaceFilesClient(request2);
+    this.assets = new AssetsClient(request2, wsBase, fetchFn, getAuthHeaders);
+    this.runtimeInstallations = new RuntimeInstallationsClient(request2);
     this.tasks = new TasksClient(request2);
     this.memory = new MemoryClient(request2);
     this.knowledge = new KnowledgeLinkClient(request2);
@@ -2968,7 +3355,7 @@ var IMClient = class {
     this.evolution = new EvolutionClient(request2);
     this.community = new CommunityHub(request2, communityHubConfig ?? void 0);
     this.files = new FilesClient(request2, wsBase, fetchFn, getAuthHeaders);
-    this.realtime = new IMRealtimeClient(wsBase);
+    this.realtime = new IMRealtimeClient(wsBase, fetchFn);
     this.offline = offlineManager ?? null;
   }
   /** IM health check */
@@ -3193,6 +3580,14 @@ var PrismerClient = class {
     return this._request("GET", `/api/parse/result/${taskId}`);
   }
   // --------------------------------------------------------------------------
+  // Models API (LLM proxy model listing)
+  // --------------------------------------------------------------------------
+  /** List LLM models exposed by the cloud LLM proxy (OpenAI format). */
+  async listModels() {
+    const res = await this._request("GET", "/api/v1/models");
+    return res.data ?? [];
+  }
+  // --------------------------------------------------------------------------
   // Convenience
   // --------------------------------------------------------------------------
   /** Search for content (convenience wrapper around load with query mode) */
@@ -7030,6 +7425,3 @@ program.parse(process.argv);
   getAPIClient,
   getIMClient
 });
-,
-  getIMClient
-});