@persistmemory/sdk 0.1.1 → 0.2.0

package/dist/client.d.ts

@@ -5,8 +5,10 @@ import { Spaces } from "./resources/spaces.js";
 import { Documents, Jobs, Sources } from "./resources/ingestion.js";
 import { Conflicts, Entities, Graph } from "./resources/knowledge.js";
 import { Conversations } from "./resources/conversations.js";
+import { Google } from "./resources/google.js";
 import { Integrations } from "./resources/integrations.js";
 import { Health } from "./resources/health.js";
+import { Agent } from "./resources/agent.js";
 /**
  * The client.
  *
@@ -31,7 +33,10 @@ export declare class PersistMemory {
     readonly conflicts: Conflicts;
     readonly conversations: Conversations;
     readonly integrations: Integrations;
+    /** Drive, mail and contacts on the user's connected Google account. */
+    readonly google: Google;
     readonly health: Health;
+    readonly agent: Agent;
     constructor(options: ClientOptions);
     /**
      * An escape hatch for an endpoint this package has not caught up with.

package/dist/http.d.ts

@@ -64,6 +64,18 @@ interface InternalRequest {
     readonly path: string;
     readonly query?: QueryParams;
     readonly body?: unknown;
+    /**
+     * Bytes, for the endpoints that take a file.
+     *
+     * Separate from `body` rather than sniffed out of it: `JSON.stringify` of a
+     * `Uint8Array` produces `{"0":137,"1":80,...}`, which is a valid request and
+     * a corrupt file - and the failure shows up as "this PDF is not a PDF" a
+     * long way from the line that caused it.
+     */
+    readonly rawBody?: Uint8Array;
+    readonly contentType?: string;
+    /** Bytes back, for a download. JSON is parsed; a file is not. */
+    readonly rawResponse?: boolean;
     readonly options?: RequestOptions;
 }
 export declare class HttpClient {
@@ -80,6 +92,14 @@ export declare class HttpClient {
     toJSON(): Record<string, unknown>;
     get<T>(path: string, query?: QueryParams, options?: RequestOptions): Promise<T>;
     post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /** POST with a file as the body. The type describes the bytes, not JSON. */
+    postBytes<T>(path: string, bytes: Uint8Array, contentType: string, query?: QueryParams, options?: RequestOptions): Promise<T>;
+    /** GET that returns bytes rather than JSON, for downloading a file. */
+    getBytes(path: string, query?: QueryParams, options?: RequestOptions): Promise<{
+        bytes: Uint8Array;
+        contentType: string;
+        filename?: string;
+    }>;
     patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
     delete<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
 }

package/dist/index.cjs

@@ -279,6 +279,27 @@ var HttpClient = class {
       ...options ? { options } : {}
     });
   }
+  /** POST with a file as the body. The type describes the bytes, not JSON. */
+  async postBytes(path, bytes, contentType, query, options) {
+    return this.#request({
+      method: "POST",
+      path,
+      rawBody: bytes,
+      contentType,
+      ...query ? { query } : {},
+      ...options ? { options } : {}
+    });
+  }
+  /** GET that returns bytes rather than JSON, for downloading a file. */
+  async getBytes(path, query, options) {
+    return this.#request({
+      method: "GET",
+      path,
+      rawResponse: true,
+      ...query ? { query } : {},
+      ...options ? { options } : {}
+    });
+  }
   async patch(path, body, options) {
     return this.#request({
       method: "PATCH",
@@ -331,11 +352,20 @@ var HttpClient = class {
         this.#fetch(url, {
           method: request.method,
           headers: this.#headers(request),
-          ...request.body !== void 0 ? { body: JSON.stringify(request.body) } : {},
+          ...request.rawBody !== void 0 ? { body: request.rawBody } : request.body !== void 0 ? { body: JSON.stringify(request.body) } : {},
           signal: deadline.signal
         }),
         deadline.signal
       );
+      if (request.rawResponse && response.ok) {
+        const disposition = response.headers.get("content-disposition") ?? "";
+        const named = /filename="([^"]+)"/.exec(disposition)?.[1];
+        return {
+          bytes: new Uint8Array(await response.arrayBuffer()),
+          contentType: response.headers.get("content-type") ?? "application/octet-stream",
+          ...named ? { filename: named } : {}
+        };
+      }
       const payload = await readBody(response);
       if (!response.ok) throw errorFromResponse(response.status, payload, response.headers);
       return payload;
@@ -356,9 +386,11 @@ var HttpClient = class {
     return {
       // The only place the key is ever read.
       authorization: `Bearer ${this.#apiKey}`,
-      accept: "application/json",
+      // A download route answers with the file's own type, so `*/*` rather
+      // than a promise to accept only JSON that the server would have to break.
+      accept: request.rawResponse ? "*/*" : "application/json",
       "user-agent": this.#userAgent,
-      ...request.body !== void 0 ? { "content-type": "application/json" } : {},
+      ...request.rawBody !== void 0 ? { "content-type": request.contentType ?? "application/octet-stream" } : request.body !== void 0 ? { "content-type": "application/json" } : {},
       ...request.options?.idempotencyKey ? { "idempotency-key": request.options.idempotencyKey } : {}
     };
   }
@@ -950,6 +982,121 @@ var Conversations = class {
   }
 };
 
+// src/resources/google.ts
+var Google = class {
+  #http;
+  constructor(http) {
+    this.#http = http;
+  }
+  /** Files by name, newest first. Omit the query for recently changed ones. */
+  async searchDrive(params = {}, options) {
+    return this.#http.get(
+      "/api/v1/google/drive/files",
+      {
+        ...params.query !== void 0 ? { query: params.query } : {},
+        ...params.limit !== void 0 ? { limit: params.limit } : {}
+      },
+      options
+    );
+  }
+  async getDriveFile(fileId, options) {
+    return this.#http.get(
+      `/api/v1/google/drive/files/${encodeURIComponent(fileId)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * The bytes of a Drive file.
+   *
+   * A Google Doc, Sheet or Slide holds no bytes of its own and is exported on
+   * the way - a document as PDF, a spreadsheet as CSV - so `filename` comes
+   * back describing what it BECAME. Writing it under the id instead produces a
+   * file nothing will open.
+   */
+  async downloadDriveFile(fileId, options) {
+    return this.#http.getBytes(
+      `/api/v1/google/drive/files/${encodeURIComponent(fileId)}/content`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * Writes a file into the user's Drive.
+   *
+   * Needs one of the Drive write permissions on their connection. A read-only
+   * grant is refused by Google, and the error names the missing permission
+   * rather than reporting a failed upload - one is fixed with a checkbox and
+   * the other sends somebody looking for a bug.
+   */
+  async saveToDrive(params, options) {
+    return this.#http.postBytes(
+      "/api/v1/google/drive/files",
+      params.bytes,
+      params.contentType ?? "application/octet-stream",
+      {
+        name: params.name,
+        ...params.folderId !== void 0 ? { folderId: params.folderId } : {}
+      },
+      options
+    );
+  }
+  /**
+   * Recent messages - senders, subjects and a one-line preview, never bodies.
+   *
+   * `query` is Gmail's own syntax passed through as written: `from:priya`,
+   * `has:attachment`, `newer_than:7d`. It selects within the connected mailbox
+   * and cannot reach another one.
+   */
+  async searchMail(params = {}, options) {
+    return this.#http.get(
+      "/api/v1/google/mail",
+      {
+        ...params.query !== void 0 ? { query: params.query } : {},
+        ...params.limit !== void 0 ? { limit: params.limit } : {}
+      },
+      options
+    );
+  }
+  /** One message, with its body and the names of what is attached. */
+  async readMail(messageId, options) {
+    return this.#http.get(
+      `/api/v1/google/mail/${encodeURIComponent(messageId)}`,
+      void 0,
+      options
+    );
+  }
+  /**
+   * The bytes of one attachment.
+   *
+   * Separate from `readMail` so listing a mailbox never drags attachments
+   * across the network: a message with a 40 MB deck should not cost 40 MB to
+   * summarise.
+   */
+  async downloadAttachment(messageId, attachmentId, options) {
+    return this.#http.getBytes(
+      `/api/v1/google/mail/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,
+      void 0,
+      options
+    );
+  }
+  /** Sends as the connected account. Needs the send permission. */
+  async sendMail(params, options) {
+    return this.#http.post("/api/v1/google/mail/send", params, options);
+  }
+  /** People in the user's contacts. Omit the query to list them. */
+  async contacts(params = {}, options) {
+    return this.#http.get(
+      "/api/v1/google/contacts",
+      {
+        ...params.query !== void 0 ? { query: params.query } : {},
+        ...params.limit !== void 0 ? { limit: params.limit } : {}
+      },
+      options
+    );
+  }
+};
+
 // src/resources/integrations.ts
 var Integrations = class {
   #http;
@@ -1036,6 +1183,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;
@@ -1049,7 +1234,10 @@ var PersistMemory = class {
   conflicts;
   conversations;
   integrations;
+  /** Drive, mail and contacts on the user's connected Google account. */
+  google;
   health;
+  agent;
   #http;
   constructor(options) {
     this.#http = new HttpClient(options);
@@ -1064,7 +1252,9 @@ var PersistMemory = class {
     this.conflicts = new Conflicts(this.#http);
     this.conversations = new Conversations(this.#http);
     this.integrations = new Integrations(this.#http);
+    this.google = new Google(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.