@persistmemory/sdk 0.1.0 → 0.1.2

package/README.md

@@ -190,6 +190,49 @@ const inAcme = await client.search.query({
 | `"universal"` | Everything you have, ignoring space boundaries. |
 | `"combined"` | The named spaces first, then everything else, ranked together. |
 
+### Deleting a Space
+
+```ts
+// The label only — every memory is detached and kept.
+await client.spaces.delete(acme.id, { memories: "keep" });
+
+// Everything in it as well.
+const { deleted, kept } = await client.spaces.delete(acme.id, { memories: "delete" });
+```
+
+There is no default, deliberately: "delete this Space" means the label to some
+people and everything inside it to others.
+
+**A memory filed in another Space too is never destroyed** — it is detached and
+left where it still belongs. `kept` counts those, `deleted` counts the ones this
+Space was the last home for.
+
+### Merging Spaces
+
+```ts
+const { space, added } = await client.spaces.merge({
+  sourceIds: [work.id, acme.id],
+  name: "Everything client-facing"
+});
+```
+
+Additive, never destructive. Both sources keep exactly what they had, a memory
+in both is filed once, and undoing it is deleting the Space that comes back.
+
+### The default Space
+
+Where a capture lands when it names none — the Telegram bot with no `/space`
+set, an MCP `remember` with no `spaceIds`, a conversation started from a chat.
+
+```ts
+await client.spaces.setDefault(work.id);
+const { space } = await client.spaces.getDefault();  // {} when there is none
+await client.spaces.setDefault(null);                // back to nothing
+```
+
+`null` clears it and is not the same as omitting the field. Having no default is
+the normal state, not a gap — nothing picks a Space on your behalf.
+
 ### Nesting, listing, updating, archiving
 
 ```ts

package/dist/client.d.ts

@@ -7,6 +7,7 @@ import { Conflicts, Entities, Graph } from "./resources/knowledge.js";
 import { Conversations } from "./resources/conversations.js";
 import { Integrations } from "./resources/integrations.js";
 import { Health } from "./resources/health.js";
+import { Agent } from "./resources/agent.js";
 /**
  * The client.
  *
@@ -32,6 +33,7 @@ export declare class PersistMemory {
     readonly conversations: Conversations;
     readonly integrations: Integrations;
     readonly health: Health;
+    readonly agent: Agent;
     constructor(options: ClientOptions);
     /**
      * An escape hatch for an endpoint this package has not caught up with.

package/dist/index.cjs

@@ -611,6 +611,58 @@ var Spaces = class {
   async create(params, options) {
     return this.#http.post("/api/v1/spaces", params, options);
   }
+  /**
+   * Deletes a Space. You must say what happens to what is in it.
+   *
+   * There is no default, here or in the API, and that is deliberate: "delete
+   * this Space" means the label to some people and everything inside it to
+   * others, and a client that guessed would destroy or keep somebody's
+   * material without being asked.
+   *
+   * `delete` never destroys a memory that is filed in another Space as well —
+   * that one is detached and left alone. `deleted` and `kept` come back so you
+   * can say what actually happened.
+   */
+  async delete(id, params, options) {
+    return this.#http.delete(
+      `/api/v1/spaces/${encodeURIComponent(id)}`,
+      params,
+      options
+    );
+  }
+  /**
+   * Merges Spaces into a NEW one, leaving every source exactly as it was.
+   *
+   * Additive, not destructive: a memory ends up in the sources AND the result,
+   * every existing search over a source returns what it did before, and
+   * undoing it is deleting the Space this returns. A memory in two sources is
+   * filed once.
+   */
+  async merge(params, options) {
+    return this.#http.post(
+      "/api/v1/spaces/merge",
+      params,
+      options
+    );
+  }
+  /**
+   * The Space this account files into when a capture names none.
+   *
+   * `{}` — an object with no `space` — means there is no default, which is the
+   * normal state rather than a gap. It is also what comes back after the Space
+   * somebody chose has been deleted.
+   */
+  async getDefault(options) {
+    return this.#http.get("/api/v1/spaces/default", void 0, options);
+  }
+  /** `null` clears it. Not the same as omitting it, which is why the type says so. */
+  async setDefault(spaceId, options) {
+    return this.#http.patch(
+      "/api/v1/spaces/default",
+      { spaceId },
+      options
+    );
+  }
   /** Renaming, retention, and archiving - `archived` is a field, not a verb. */
   async update(id, params, options) {
     return this.#http.patch(`/api/v1/spaces/${encodeURIComponent(id)}`, params, options);
@@ -984,6 +1036,44 @@ var Health = class {
   }
 };
 
+// src/resources/agent.ts
+var Agent = class {
+  #http;
+  constructor(http) {
+    this.#http = http;
+  }
+  /** The row, including whether it finished and how large the result is. */
+  async request(id, options) {
+    return this.#http.get(
+      `/api/v1/agent/request/${encodeURIComponent(id)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * A short-lived link to the bytes of a finished request.
+   *
+   * Returns the URL rather than the file, and that is a deliberate limit of
+   * this package rather than an oversight. The transport under every other
+   * method parses JSON, retries, and attaches the API key; none of those is
+   * right for a hundred-megabyte binary body, and building a second request
+   * path inside the SDK to serve one method is how a client ends up with two
+   * retry policies that differ only during an outage. Fetch the URL with
+   * whatever already streams in your runtime - it needs no credential, which
+   * is the whole reason it is signed.
+   *
+   * Treat the URL as the file. It is a bearer credential for exactly one
+   * object, it expires in minutes, and it should not be logged or stored.
+   */
+  async downloadLink(id, options) {
+    return this.#http.get(
+      `/api/v1/agent/request/${encodeURIComponent(id)}/download`,
+      void 0,
+      options
+    );
+  }
+};
+
 // src/client.ts
 var PersistMemory = class {
   memories;
@@ -998,6 +1088,7 @@ var PersistMemory = class {
   conversations;
   integrations;
   health;
+  agent;
   #http;
   constructor(options) {
     this.#http = new HttpClient(options);
@@ -1013,6 +1104,7 @@ var PersistMemory = class {
     this.conversations = new Conversations(this.#http);
     this.integrations = new Integrations(this.#http);
     this.health = new Health(this.#http);
+    this.agent = new Agent(this.#http);
   }
   /**
    * An escape hatch for an endpoint this package has not caught up with.