@pingagent/sdk 0.1.2 → 0.1.4

package/dist/chunk-YS54ADYV.js

@@ -0,0 +1,1350 @@
+// src/client.ts
+import { SCHEMA_TASK, SCHEMA_CONTACT_REQUEST, SCHEMA_RESULT, SCHEMA_RECEIPT, SCHEMA_TEXT } from "@pingagent/schemas";
+import {
+  buildUnsignedEnvelope,
+  signEnvelope
+} from "@pingagent/protocol";
+
+// src/transport.ts
+import { ErrorCode } from "@pingagent/schemas";
+var HttpTransport = class {
+  serverUrl;
+  accessToken;
+  maxRetries;
+  onTokenRefreshed;
+  constructor(opts) {
+    this.serverUrl = opts.serverUrl.replace(/\/$/, "");
+    this.accessToken = opts.accessToken;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.onTokenRefreshed = opts.onTokenRefreshed;
+  }
+  setToken(token) {
+    this.accessToken = token;
+  }
+  /** Fetch a URL with Bearer auth (e.g. artifact upload/download). */
+  async fetchWithAuth(url, options = {}) {
+    const headers = { Authorization: `Bearer ${this.accessToken}` };
+    if (options.contentType) headers["Content-Type"] = options.contentType;
+    const res = await fetch(url, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body ?? void 0
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Request failed (${res.status}): ${text.slice(0, 200)}`);
+    }
+    return res.arrayBuffer();
+  }
+  async request(method, path4, body, skipAuth = false) {
+    const url = `${this.serverUrl}${path4}`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (!skipAuth) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    let lastError = null;
+    const delays = [1e3, 2e3, 4e3];
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const res = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0
+        });
+        const text = await res.text();
+        let data;
+        try {
+          data = text ? JSON.parse(text) : {};
+        } catch {
+          throw new Error(`Server returned non-JSON (${res.status}): ${text.slice(0, 200)}`);
+        }
+        if (res.status === 401 && data.error?.code === ErrorCode.TOKEN_EXPIRED && attempt === 0) {
+          const refreshed = await this.refreshToken();
+          if (refreshed) {
+            headers["Authorization"] = `Bearer ${this.accessToken}`;
+            continue;
+          }
+        }
+        if (res.status === 429 && data.error?.retry_after_ms) {
+          await sleep(data.error.retry_after_ms);
+          continue;
+        }
+        if (res.status >= 500 && attempt < this.maxRetries) {
+          await sleep(delays[attempt] ?? 4e3);
+          continue;
+        }
+        return data;
+      } catch (e) {
+        lastError = e;
+        if (attempt < this.maxRetries) {
+          await sleep(delays[attempt] ?? 4e3);
+        }
+      }
+    }
+    throw lastError ?? new Error("Request failed after retries");
+  }
+  async refreshToken() {
+    try {
+      const res = await fetch(`${this.serverUrl}/v1/auth/refresh`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: this.accessToken })
+      });
+      if (!res.ok) return false;
+      const text = await res.text();
+      let data;
+      try {
+        data = text ? JSON.parse(text) : {};
+      } catch {
+        return false;
+      }
+      if (!data.ok || !data.data) return false;
+      this.accessToken = data.data.access_token;
+      const expiresAt = Date.now() + data.data.expires_ms;
+      this.onTokenRefreshed?.(data.data.access_token, expiresAt);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/contacts.ts
+function rowToContact(row) {
+  return {
+    did: row.did,
+    alias: row.alias ?? void 0,
+    display_name: row.display_name ?? void 0,
+    notes: row.notes ?? void 0,
+    conversation_id: row.conversation_id ?? void 0,
+    trusted: row.trusted === 1,
+    added_at: row.added_at,
+    last_message_at: row.last_message_at ?? void 0,
+    tags: row.tags ? JSON.parse(row.tags) : void 0
+  };
+}
+var ContactManager = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  add(contact) {
+    const db = this.store.getDb();
+    const now = contact.added_at ?? Date.now();
+    db.prepare(`
+      INSERT INTO contacts (did, alias, display_name, notes, conversation_id, trusted, added_at, last_message_at, tags)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(did) DO UPDATE SET
+        alias = COALESCE(excluded.alias, contacts.alias),
+        display_name = COALESCE(excluded.display_name, contacts.display_name),
+        notes = COALESCE(excluded.notes, contacts.notes),
+        conversation_id = COALESCE(excluded.conversation_id, contacts.conversation_id),
+        trusted = excluded.trusted,
+        last_message_at = COALESCE(excluded.last_message_at, contacts.last_message_at),
+        tags = COALESCE(excluded.tags, contacts.tags)
+    `).run(
+      contact.did,
+      contact.alias ?? null,
+      contact.display_name ?? null,
+      contact.notes ?? null,
+      contact.conversation_id ?? null,
+      contact.trusted ? 1 : 0,
+      now,
+      contact.last_message_at ?? null,
+      contact.tags ? JSON.stringify(contact.tags) : null
+    );
+    return { ...contact, added_at: now };
+  }
+  remove(did) {
+    const result = this.store.getDb().prepare("DELETE FROM contacts WHERE did = ?").run(did);
+    return result.changes > 0;
+  }
+  get(did) {
+    const row = this.store.getDb().prepare("SELECT * FROM contacts WHERE did = ?").get(did);
+    return row ? rowToContact(row) : null;
+  }
+  update(did, updates) {
+    const existing = this.get(did);
+    if (!existing) return null;
+    const fields = [];
+    const values = [];
+    if (updates.alias !== void 0) {
+      fields.push("alias = ?");
+      values.push(updates.alias);
+    }
+    if (updates.display_name !== void 0) {
+      fields.push("display_name = ?");
+      values.push(updates.display_name);
+    }
+    if (updates.notes !== void 0) {
+      fields.push("notes = ?");
+      values.push(updates.notes);
+    }
+    if (updates.conversation_id !== void 0) {
+      fields.push("conversation_id = ?");
+      values.push(updates.conversation_id);
+    }
+    if (updates.trusted !== void 0) {
+      fields.push("trusted = ?");
+      values.push(updates.trusted ? 1 : 0);
+    }
+    if (updates.last_message_at !== void 0) {
+      fields.push("last_message_at = ?");
+      values.push(updates.last_message_at);
+    }
+    if (updates.tags !== void 0) {
+      fields.push("tags = ?");
+      values.push(JSON.stringify(updates.tags));
+    }
+    if (fields.length === 0) return existing;
+    values.push(did);
+    this.store.getDb().prepare(`UPDATE contacts SET ${fields.join(", ")} WHERE did = ?`).run(...values);
+    return this.get(did);
+  }
+  list(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts?.trusted !== void 0) {
+      conditions.push("trusted = ?");
+      params.push(opts.trusted ? 1 : 0);
+    }
+    if (opts?.tag) {
+      conditions.push("tags LIKE ?");
+      params.push(`%"${opts.tag}"%`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = opts?.limit ? `LIMIT ${opts.limit}` : "";
+    const offset = opts?.offset ? `OFFSET ${opts.offset}` : "";
+    const rows = this.store.getDb().prepare(`SELECT * FROM contacts ${where} ORDER BY added_at DESC ${limit} ${offset}`).all(...params);
+    return rows.map(rowToContact);
+  }
+  search(query) {
+    const pattern = `%${query}%`;
+    const rows = this.store.getDb().prepare(`
+        SELECT * FROM contacts
+        WHERE did LIKE ? OR alias LIKE ? OR display_name LIKE ? OR notes LIKE ?
+        ORDER BY added_at DESC
+      `).all(pattern, pattern, pattern, pattern);
+    return rows.map(rowToContact);
+  }
+  export(format = "json") {
+    const contacts = this.list();
+    if (format === "csv") {
+      const header = "did,alias,display_name,notes,conversation_id,trusted,added_at,last_message_at,tags";
+      const rows = contacts.map(
+        (c) => [
+          c.did,
+          c.alias ?? "",
+          c.display_name ?? "",
+          c.notes ?? "",
+          c.conversation_id ?? "",
+          c.trusted,
+          c.added_at,
+          c.last_message_at ?? "",
+          c.tags ? JSON.stringify(c.tags) : ""
+        ].map((v) => `"${String(v).replace(/"/g, '""')}"`).join(",")
+      );
+      return [header, ...rows].join("\n");
+    }
+    return JSON.stringify(contacts, null, 2);
+  }
+  import(data, format = "json") {
+    let imported = 0;
+    let skipped = 0;
+    if (format === "json") {
+      const contacts = JSON.parse(data);
+      for (const c of contacts) {
+        try {
+          this.add(c);
+          imported++;
+        } catch {
+          skipped++;
+        }
+      }
+    } else {
+      const lines = data.split("\n").filter((l) => l.trim());
+      for (let i = 1; i < lines.length; i++) {
+        try {
+          const cols = parseCsvLine(lines[i]);
+          this.add({
+            did: cols[0],
+            alias: cols[1] || void 0,
+            display_name: cols[2] || void 0,
+            notes: cols[3] || void 0,
+            conversation_id: cols[4] || void 0,
+            trusted: cols[5] === "1" || cols[5] === "true",
+            added_at: parseInt(cols[6]) || Date.now(),
+            last_message_at: cols[7] ? parseInt(cols[7]) : void 0,
+            tags: cols[8] ? JSON.parse(cols[8]) : void 0
+          });
+          imported++;
+        } catch {
+          skipped++;
+        }
+      }
+    }
+    return { imported, skipped };
+  }
+};
+function parseCsvLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ",") {
+        result.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current);
+  return result;
+}
+
+// src/history.ts
+function rowToMessage(row) {
+  return {
+    conversation_id: row.conversation_id,
+    message_id: row.message_id,
+    seq: row.seq ?? void 0,
+    sender_did: row.sender_did,
+    schema: row.schema,
+    payload: JSON.parse(row.payload),
+    ts_ms: row.ts_ms,
+    direction: row.direction
+  };
+}
+var HistoryManager = class {
+  store;
+  constructor(store) {
+    this.store = store;
+  }
+  save(messages) {
+    const db = this.store.getDb();
+    const stmt = db.prepare(`
+      INSERT INTO messages (conversation_id, message_id, seq, sender_did, schema, payload, ts_ms, direction)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(message_id) DO UPDATE SET
+        seq = COALESCE(excluded.seq, messages.seq),
+        payload = excluded.payload,
+        ts_ms = excluded.ts_ms
+    `);
+    let count = 0;
+    const tx = db.transaction(() => {
+      for (const msg of messages) {
+        stmt.run(
+          msg.conversation_id,
+          msg.message_id,
+          msg.seq ?? null,
+          msg.sender_did,
+          msg.schema,
+          JSON.stringify(msg.payload),
+          msg.ts_ms,
+          msg.direction
+        );
+        count++;
+      }
+    });
+    tx();
+    return count;
+  }
+  list(conversationId, opts) {
+    const conditions = ["conversation_id = ?"];
+    const params = [conversationId];
+    if (opts?.beforeSeq !== void 0) {
+      conditions.push("seq < ?");
+      params.push(opts.beforeSeq);
+    }
+    if (opts?.afterSeq !== void 0) {
+      conditions.push("seq > ?");
+      params.push(opts.afterSeq);
+    }
+    if (opts?.beforeTsMs !== void 0) {
+      conditions.push("ts_ms < ?");
+      params.push(opts.beforeTsMs);
+    }
+    if (opts?.afterTsMs !== void 0) {
+      conditions.push("ts_ms > ?");
+      params.push(opts.afterTsMs);
+    }
+    const limit = opts?.limit ?? 100;
+    const rows = this.store.getDb().prepare(`SELECT * FROM messages WHERE ${conditions.join(" AND ")} ORDER BY COALESCE(seq, ts_ms) ASC LIMIT ?`).all(...params, limit);
+    return rows.map(rowToMessage);
+  }
+  /**
+   * List the most recent N messages *before* a seq (paging older history).
+   * Only compares rows where seq is not null.
+   */
+  listBeforeSeq(conversationId, beforeSeq, limit) {
+    const rows = this.store.getDb().prepare(
+      `SELECT * FROM messages
+         WHERE conversation_id = ? AND seq IS NOT NULL AND seq < ?
+         ORDER BY seq DESC
+         LIMIT ?`
+    ).all(conversationId, beforeSeq, limit);
+    return rows.map(rowToMessage).reverse();
+  }
+  /**
+   * List the most recent N messages *before* a timestamp (paging older history).
+   */
+  listBeforeTs(conversationId, beforeTsMs, limit) {
+    const rows = this.store.getDb().prepare(
+      `SELECT * FROM messages
+         WHERE conversation_id = ? AND ts_ms < ?
+         ORDER BY ts_ms DESC
+         LIMIT ?`
+    ).all(conversationId, beforeTsMs, limit);
+    return rows.map(rowToMessage).reverse();
+  }
+  /** Returns the N most recent messages (chronological order, oldest to newest of those N). */
+  listRecent(conversationId, limit) {
+    const rows = this.store.getDb().prepare(
+      `SELECT * FROM messages WHERE conversation_id = ? ORDER BY COALESCE(seq, ts_ms) DESC LIMIT ?`
+    ).all(conversationId, limit);
+    return rows.map(rowToMessage).reverse();
+  }
+  search(query, opts) {
+    const conditions = ["payload LIKE ?"];
+    const params = [`%${query}%`];
+    if (opts?.conversationId) {
+      conditions.push("conversation_id = ?");
+      params.push(opts.conversationId);
+    }
+    const limit = opts?.limit ?? 50;
+    const rows = this.store.getDb().prepare(`SELECT * FROM messages WHERE ${conditions.join(" AND ")} ORDER BY ts_ms DESC LIMIT ?`).all(...params, limit);
+    return rows.map(rowToMessage);
+  }
+  delete(conversationId) {
+    const result = this.store.getDb().prepare("DELETE FROM messages WHERE conversation_id = ?").run(conversationId);
+    this.store.getDb().prepare("DELETE FROM sync_state WHERE conversation_id = ?").run(conversationId);
+    return result.changes;
+  }
+  listConversations() {
+    const rows = this.store.getDb().prepare(`
+        SELECT conversation_id, COUNT(*) as message_count, MAX(ts_ms) as last_message_at
+        FROM messages
+        GROUP BY conversation_id
+        ORDER BY last_message_at DESC
+      `).all();
+    return rows;
+  }
+  getLastSyncedSeq(conversationId) {
+    const row = this.store.getDb().prepare("SELECT last_synced_seq FROM sync_state WHERE conversation_id = ?").get(conversationId);
+    return row?.last_synced_seq ?? 0;
+  }
+  setLastSyncedSeq(conversationId, seq) {
+    this.store.getDb().prepare(`
+      INSERT INTO sync_state (conversation_id, last_synced_seq, last_synced_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(conversation_id) DO UPDATE SET last_synced_seq = excluded.last_synced_seq, last_synced_at = excluded.last_synced_at
+    `).run(conversationId, seq, Date.now());
+  }
+  export(opts) {
+    const format = opts?.format ?? "json";
+    let messages;
+    if (opts?.conversationId) {
+      messages = this.list(opts.conversationId, { limit: 1e5 });
+    } else {
+      const rows = this.store.getDb().prepare("SELECT * FROM messages ORDER BY ts_ms ASC").all();
+      messages = rows.map(rowToMessage);
+    }
+    if (format === "csv") {
+      const header = "conversation_id,message_id,seq,sender_did,schema,payload,ts_ms,direction";
+      const lines = messages.map(
+        (m) => [
+          m.conversation_id,
+          m.message_id,
+          m.seq ?? "",
+          m.sender_did,
+          m.schema,
+          JSON.stringify(m.payload),
+          m.ts_ms,
+          m.direction
+        ].map((v) => `"${String(v).replace(/"/g, '""')}"`).join(",")
+      );
+      return [header, ...lines].join("\n");
+    }
+    return JSON.stringify(messages, null, 2);
+  }
+  async syncFromServer(client, conversationId, opts) {
+    const sinceSeq = opts?.full ? 0 : this.getLastSyncedSeq(conversationId);
+    let totalSynced = 0;
+    let currentSeq = sinceSeq;
+    while (true) {
+      const res = await client.fetchInbox(conversationId, {
+        sinceSeq: currentSeq,
+        limit: 50
+      });
+      if (!res.ok || !res.data || res.data.messages.length === 0) break;
+      const messages = res.data.messages.map((msg) => ({
+        conversation_id: conversationId,
+        message_id: msg.message_id,
+        seq: msg.seq,
+        sender_did: msg.sender_did,
+        schema: msg.schema,
+        payload: msg.payload,
+        ts_ms: msg.ts_ms,
+        direction: "received"
+      }));
+      this.save(messages);
+      totalSynced += messages.length;
+      currentSeq = res.data.next_since_seq;
+      this.setLastSyncedSeq(conversationId, currentSeq);
+      if (!res.data.has_more) break;
+    }
+    return { synced: totalSynced };
+  }
+};
+
+// src/client.ts
+var PingAgentClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.identity = opts.identity;
+    this.transport = new HttpTransport({
+      serverUrl: opts.serverUrl,
+      accessToken: opts.accessToken,
+      onTokenRefreshed: opts.onTokenRefreshed
+    });
+    if (opts.store) {
+      this.contactManager = new ContactManager(opts.store);
+      this.historyManager = new HistoryManager(opts.store);
+    }
+  }
+  transport;
+  identity;
+  contactManager;
+  historyManager;
+  getContactManager() {
+    return this.contactManager;
+  }
+  getHistoryManager() {
+    return this.historyManager;
+  }
+  /** Update the in-memory access token (e.g. after proactive refresh from disk). */
+  setAccessToken(token) {
+    this.transport.setToken(token);
+  }
+  async register(developerToken) {
+    let binary = "";
+    for (const b of this.identity.publicKey) binary += String.fromCharCode(b);
+    const publicKeyBase64 = btoa(binary);
+    return this.transport.request("POST", "/v1/agent/register", {
+      device_id: this.identity.deviceId,
+      public_key: publicKeyBase64,
+      developer_token: developerToken
+    }, true);
+  }
+  async openConversation(targetDid) {
+    return this.transport.request("POST", "/v1/conversations/open", {
+      targets: [targetDid]
+    });
+  }
+  async sendMessage(conversationId, schema, payload) {
+    const ttlMs = schema === SCHEMA_TEXT ? 6048e5 : void 0;
+    const unsigned = buildUnsignedEnvelope({
+      type: "message",
+      conversationId,
+      senderDid: this.identity.did,
+      senderDeviceId: this.identity.deviceId,
+      schema,
+      payload,
+      ttlMs
+    });
+    const signed = signEnvelope(unsigned, this.identity.privateKey);
+    const res = await this.transport.request("POST", "/v1/messages/send", signed);
+    if (res.ok && this.historyManager) {
+      this.historyManager.save([{
+        conversation_id: conversationId,
+        message_id: signed.message_id,
+        seq: res.data?.seq,
+        sender_did: this.identity.did,
+        schema,
+        payload,
+        ts_ms: signed.ts_ms,
+        direction: "sent"
+      }]);
+    }
+    return res;
+  }
+  async sendTask(conversationId, task) {
+    return this.sendMessage(conversationId, SCHEMA_TASK, {
+      ...task,
+      idempotency_key: task.task_id,
+      expected_output_schema: SCHEMA_RESULT
+    });
+  }
+  async sendContactRequest(conversationId, message) {
+    const { v7: uuidv7 } = await import("uuid");
+    return this.sendMessage(conversationId, SCHEMA_CONTACT_REQUEST, {
+      request_id: `r_${uuidv7()}`,
+      from_did: this.identity.did,
+      to_did: "",
+      capabilities: ["task", "result", "files"],
+      message,
+      expires_ms: 864e5
+    });
+  }
+  async fetchInbox(conversationId, opts) {
+    const params = new URLSearchParams({
+      conversation_id: conversationId,
+      since_seq: String(opts?.sinceSeq ?? 0),
+      limit: String(opts?.limit ?? 50),
+      box: opts?.box ?? "ready"
+    });
+    const res = await this.transport.request("GET", `/v1/inbox/fetch?${params}`);
+    if (res.ok && res.data && this.historyManager) {
+      const msgs = res.data.messages.map((msg) => ({
+        conversation_id: conversationId,
+        message_id: msg.message_id,
+        seq: msg.seq,
+        sender_did: msg.sender_did,
+        schema: msg.schema,
+        payload: msg.payload,
+        ts_ms: msg.ts_ms,
+        direction: msg.sender_did === this.identity.did ? "sent" : "received"
+      }));
+      if (msgs.length > 0) {
+        this.historyManager.save(msgs);
+        const maxSeq = Math.max(...msgs.map((m) => m.seq ?? 0));
+        if (maxSeq > 0) this.historyManager.setLastSyncedSeq(conversationId, maxSeq);
+      }
+    }
+    return res;
+  }
+  async ack(conversationId, forMessageId, status, opts) {
+    return this.transport.request("POST", "/v1/receipts/ack", {
+      conversation_id: conversationId,
+      for_message_id: forMessageId,
+      for_task_id: opts?.forTaskId,
+      status,
+      reason: opts?.reason,
+      detail: opts?.detail
+    });
+  }
+  async approveContact(conversationId) {
+    const res = await this.transport.request("POST", "/v1/control/approve_contact", {
+      conversation_id: conversationId
+    });
+    if (res.ok && this.contactManager) {
+      const pendingMessages = this.historyManager?.list(conversationId, { limit: 1 });
+      const senderDid = pendingMessages?.[0]?.sender_did;
+      if (senderDid && senderDid !== this.identity.did) {
+        this.contactManager.add({
+          did: senderDid,
+          conversation_id: res.data?.dm_conversation_id ?? conversationId,
+          trusted: true
+        });
+      }
+    }
+    return res;
+  }
+  async revokeConversation(conversationId) {
+    return this.transport.request("POST", "/v1/control/revoke_conversation", {
+      conversation_id: conversationId
+    });
+  }
+  async cancelTask(conversationId, taskId) {
+    return this.transport.request("POST", "/v1/control/cancel_task", {
+      conversation_id: conversationId,
+      task_id: taskId
+    });
+  }
+  async blockSender(conversationId, senderDid) {
+    return this.transport.request("POST", "/v1/control/block_sender", {
+      conversation_id: conversationId,
+      sender_did: senderDid
+    });
+  }
+  async acquireLease(conversationId) {
+    return this.transport.request("POST", "/v1/lease/acquire", {
+      conversation_id: conversationId
+    });
+  }
+  async renewLease(conversationId) {
+    return this.transport.request("POST", "/v1/lease/renew", {
+      conversation_id: conversationId
+    });
+  }
+  async releaseLease(conversationId) {
+    return this.transport.request("POST", "/v1/lease/release", {
+      conversation_id: conversationId
+    });
+  }
+  async uploadArtifact(content) {
+    const presignRes = await this.transport.request("POST", "/v1/artifacts/presign_upload", {
+      size: content.length,
+      content_type: "application/octet-stream"
+    });
+    if (!presignRes.ok || !presignRes.data) throw new Error("Failed to presign upload");
+    const { upload_url, artifact_ref } = presignRes.data;
+    await this.transport.fetchWithAuth(upload_url, {
+      method: "PUT",
+      body: content,
+      contentType: "application/octet-stream"
+    });
+    const { createHash } = await import("crypto");
+    const hash = createHash("sha256").update(content).digest("hex");
+    return { artifact_ref, sha256: hash, size: content.length };
+  }
+  async downloadArtifact(artifactRef, expectedSha256, expectedSize) {
+    const presignRes = await this.transport.request("POST", "/v1/artifacts/presign_download", {
+      artifact_ref: artifactRef
+    });
+    if (!presignRes.ok || !presignRes.data) throw new Error("Failed to presign download");
+    const buffer = Buffer.from(await this.transport.fetchWithAuth(presignRes.data.download_url));
+    if (buffer.length !== expectedSize) {
+      throw new Error(`Size mismatch: expected ${expectedSize}, got ${buffer.length}`);
+    }
+    const { createHash } = await import("crypto");
+    const hash = createHash("sha256").update(buffer).digest("hex");
+    if (hash !== expectedSha256) {
+      throw new Error(`SHA256 mismatch: expected ${expectedSha256}, got ${hash}`);
+    }
+    return buffer;
+  }
+  async getSubscription() {
+    return this.transport.request("GET", "/v1/subscription");
+  }
+  async resolveAlias(alias) {
+    return this.transport.request("GET", `/v1/directory/resolve?alias=${encodeURIComponent(alias)}`);
+  }
+  async registerAlias(alias) {
+    return this.transport.request("POST", "/v1/directory/alias", { alias });
+  }
+  async listConversations(opts) {
+    const params = new URLSearchParams();
+    if (opts?.type) params.set("type", opts.type);
+    const qs = params.toString();
+    return this.transport.request("GET", `/v1/conversations/list${qs ? "?" + qs : ""}`);
+  }
+  async getProfile() {
+    return this.transport.request("GET", "/v1/directory/profile");
+  }
+  async updateProfile(profile) {
+    return this.transport.request("POST", "/v1/directory/profile", profile);
+  }
+  async enableDiscovery() {
+    return this.transport.request("POST", "/v1/directory/enable_discovery");
+  }
+  async disableDiscovery() {
+    return this.transport.request("POST", "/v1/directory/disable_discovery");
+  }
+  async browseDirectory(opts) {
+    const params = new URLSearchParams();
+    if (opts?.tag) params.set("tag", opts.tag);
+    if (opts?.query) params.set("q", opts.query);
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    if (opts?.offset != null) params.set("offset", String(opts.offset));
+    if (opts?.sort) params.set("sort", opts.sort);
+    const qs = params.toString();
+    return this.transport.request("GET", `/v1/directory/browse${qs ? "?" + qs : ""}`);
+  }
+  async publishPost(opts) {
+    return this.transport.request("POST", "/v1/feed/publish", { text: opts.text, artifact_ref: opts.artifact_ref });
+  }
+  async listFeedPublic(opts) {
+    const params = new URLSearchParams();
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    if (opts?.since != null) params.set("since", String(opts.since));
+    const qs = params.toString();
+    return this.transport.request("GET", `/v1/feed/public${qs ? "?" + qs : ""}`, void 0, true);
+  }
+  async listFeedByDid(did, opts) {
+    const params = new URLSearchParams({ did });
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    return this.transport.request("GET", `/v1/feed/by_did?${params.toString()}`, void 0, true);
+  }
+  async createChannel(opts) {
+    return this.transport.request("POST", "/v1/channels/create", {
+      name: opts.name,
+      alias: opts.alias,
+      description: opts.description,
+      join_policy: "open",
+      discoverable: opts.discoverable
+    });
+  }
+  async updateChannel(opts) {
+    const alias = opts.alias.replace(/^@ch\//, "");
+    return this.transport.request("PATCH", "/v1/channels/update", {
+      alias,
+      name: opts.name,
+      description: opts.description,
+      discoverable: opts.discoverable
+    });
+  }
+  async deleteChannel(alias) {
+    const a = alias.replace(/^@ch\//, "");
+    return this.transport.request("DELETE", "/v1/channels/delete", { alias: a });
+  }
+  async discoverChannels(opts) {
+    const params = new URLSearchParams();
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    if (opts?.query) params.set("q", opts.query);
+    const qs = params.toString();
+    return this.transport.request("GET", `/v1/channels/discover${qs ? "?" + qs : ""}`, void 0, true);
+  }
+  async joinChannel(alias) {
+    return this.transport.request("POST", "/v1/channels/join", { alias });
+  }
+  getDid() {
+    return this.identity.did;
+  }
+  // === Billing: device linking ===
+  async createBillingLinkCode() {
+    return this.transport.request("POST", "/v1/billing/link-code");
+  }
+  async redeemBillingLink(code) {
+    return this.transport.request("POST", "/v1/billing/link", { code });
+  }
+  async unlinkBillingDevice(did) {
+    return this.transport.request("POST", "/v1/billing/unlink", { did });
+  }
+  async getLinkedDevices() {
+    return this.transport.request("GET", "/v1/billing/linked-devices");
+  }
+  // P0: High-level send-task-and-wait
+  async sendTaskAndWait(targetDid, task, opts) {
+    const { v7: uuidv7 } = await import("uuid");
+    const timeout = opts?.timeoutMs ?? 12e4;
+    const pollInterval = opts?.pollIntervalMs ?? 2e3;
+    const taskId = `t_${uuidv7()}`;
+    const startTime = Date.now();
+    const openRes = await this.openConversation(targetDid);
+    if (!openRes.ok || !openRes.data) {
+      return { status: "error", task_id: taskId, error: { code: "E_OPEN_FAILED", message: "Failed to open conversation" }, elapsed_ms: Date.now() - startTime };
+    }
+    let conversationId = openRes.data.conversation_id;
+    if (!openRes.data.trusted) {
+      await this.sendContactRequest(conversationId, task.title);
+      const approvalDeadline = startTime + timeout;
+      while (Date.now() < approvalDeadline) {
+        await sleep2(pollInterval);
+        const reopen = await this.openConversation(targetDid);
+        if (reopen.ok && reopen.data?.trusted) {
+          conversationId = reopen.data.conversation_id;
+          break;
+        }
+      }
+      if (Date.now() >= approvalDeadline) {
+        return { status: "error", task_id: taskId, error: { code: "E_NOT_APPROVED", message: "Contact request not approved within timeout" }, elapsed_ms: Date.now() - startTime };
+      }
+    }
+    const sendRes = await this.sendTask(conversationId, { task_id: taskId, ...task });
+    if (!sendRes.ok) {
+      return { status: "error", task_id: taskId, error: { code: sendRes.error?.code ?? "E_SEND_FAILED", message: sendRes.error?.message ?? "Send failed" }, elapsed_ms: Date.now() - startTime };
+    }
+    const sinceSeq = sendRes.data?.seq ?? 0;
+    const deadline = startTime + timeout;
+    while (Date.now() < deadline) {
+      await sleep2(pollInterval);
+      const fetchRes = await this.fetchInbox(conversationId, { sinceSeq });
+      if (!fetchRes.ok || !fetchRes.data) continue;
+      for (const msg of fetchRes.data.messages) {
+        if (msg.schema === SCHEMA_RESULT && msg.payload?.task_id === taskId) {
+          return {
+            status: msg.payload.status === "ok" ? "ok" : "error",
+            task_id: taskId,
+            result: msg.payload.output,
+            error: msg.payload.error,
+            elapsed_ms: Date.now() - startTime
+          };
+        }
+        if (msg.schema === SCHEMA_RECEIPT && msg.payload?.for_task_id === taskId && msg.payload?.status === "failed") {
+          return {
+            status: "error",
+            task_id: taskId,
+            error: { code: msg.payload.reason ?? "E_TASK_FAILED", message: msg.payload.reason ?? "Task failed" },
+            elapsed_ms: Date.now() - startTime
+          };
+        }
+      }
+    }
+    return { status: "error", task_id: taskId, error: { code: "E_TIMEOUT", message: `No result within ${timeout}ms` }, elapsed_ms: timeout };
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/identity.ts
+import * as fs from "fs";
+import * as path2 from "path";
+import { generateIdentity as genId } from "@pingagent/protocol";
+
+// src/paths.ts
+import * as path from "path";
+import * as os from "os";
+var DEFAULT_ROOT_DIR = path.join(os.homedir(), ".pingagent");
+function getRootDir() {
+  return process.env.PINGAGENT_ROOT_DIR || DEFAULT_ROOT_DIR;
+}
+function getProfile() {
+  const p = process.env.PINGAGENT_PROFILE;
+  if (!p) return void 0;
+  return p.trim() || void 0;
+}
+function getIdentityPath(explicitPath) {
+  const envPath = process.env.PINGAGENT_IDENTITY_PATH?.trim();
+  if (explicitPath) return explicitPath;
+  if (envPath) return path.resolve(envPath.replace(/^~(?=\/|$)/, os.homedir()));
+  const root = getRootDir();
+  const profile = getProfile();
+  if (!profile) {
+    return path.join(root, "identity.json");
+  }
+  return path.join(root, "profiles", profile, "identity.json");
+}
+function getStorePath(explicitPath) {
+  const envPath = process.env.PINGAGENT_STORE_PATH?.trim();
+  if (explicitPath) return explicitPath;
+  if (envPath) return path.resolve(envPath.replace(/^~(?=\/|$)/, os.homedir()));
+  const root = getRootDir();
+  const profile = getProfile();
+  if (!profile) {
+    return path.join(root, "store.db");
+  }
+  return path.join(root, "profiles", profile, "store.db");
+}
+
+// src/identity.ts
+function toBase64(bytes) {
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary);
+}
+function fromBase64(b64) {
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function generateIdentity() {
+  return genId();
+}
+function identityExists(identityPath) {
+  return fs.existsSync(getIdentityPath(identityPath));
+}
+function loadIdentity(identityPath) {
+  const p = getIdentityPath(identityPath);
+  const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+  return {
+    publicKey: fromBase64(data.public_key),
+    privateKey: fromBase64(data.private_key),
+    did: data.did,
+    deviceId: data.device_id,
+    serverUrl: data.server_url,
+    accessToken: data.access_token,
+    tokenExpiresAt: data.token_expires_at,
+    mode: data.mode
+  };
+}
+function saveIdentity(identity, opts, identityPath) {
+  const p = getIdentityPath(identityPath);
+  const dir = path2.dirname(p);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const stored = {
+    public_key: toBase64(identity.publicKey),
+    private_key: toBase64(identity.privateKey),
+    did: identity.did,
+    device_id: identity.deviceId,
+    server_url: opts?.serverUrl,
+    access_token: opts?.accessToken,
+    token_expires_at: opts?.tokenExpiresAt,
+    mode: opts?.mode,
+    alias: opts?.alias
+  };
+  fs.writeFileSync(p, JSON.stringify(stored, null, 2), { mode: 384 });
+}
+function updateStoredToken(accessToken, expiresAt, identityPath) {
+  const p = getIdentityPath(identityPath);
+  const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+  data.access_token = accessToken;
+  data.token_expires_at = expiresAt;
+  fs.writeFileSync(p, JSON.stringify(data, null, 2), { mode: 384 });
+}
+
+// src/auth.ts
+var REFRESH_GRACE_MS = 5 * 60 * 1e3;
+async function ensureTokenValid(identityPath, serverUrl) {
+  if (!identityExists(identityPath)) return false;
+  const id = loadIdentity(identityPath);
+  const token = id.accessToken;
+  const expiresAt = id.tokenExpiresAt;
+  if (!token || expiresAt == null) return false;
+  const now = Date.now();
+  if (expiresAt > now + REFRESH_GRACE_MS) return false;
+  const baseUrl = (serverUrl ?? id.serverUrl ?? "https://pingagent.chat").replace(/\/$/, "");
+  try {
+    const res = await fetch(`${baseUrl}/v1/auth/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ access_token: token })
+    });
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : {};
+    } catch {
+      return false;
+    }
+    if (!res.ok || !data.ok || !data.data?.access_token || data.data.expires_ms == null) return false;
+    const newExpiresAt = now + data.data.expires_ms;
+    updateStoredToken(data.data.access_token, newExpiresAt, identityPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/store.ts
+import Database from "better-sqlite3";
+import * as fs2 from "fs";
+import * as path3 from "path";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS contacts (
+  did TEXT PRIMARY KEY,
+  alias TEXT,
+  display_name TEXT,
+  notes TEXT,
+  conversation_id TEXT,
+  trusted INTEGER NOT NULL DEFAULT 0,
+  added_at INTEGER NOT NULL,
+  last_message_at INTEGER,
+  tags TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_contacts_alias ON contacts(alias);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  conversation_id TEXT NOT NULL,
+  message_id TEXT NOT NULL UNIQUE,
+  seq INTEGER,
+  sender_did TEXT NOT NULL,
+  schema TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  ts_ms INTEGER NOT NULL,
+  direction TEXT NOT NULL CHECK(direction IN ('sent', 'received'))
+);
+CREATE INDEX IF NOT EXISTS idx_messages_conv_seq ON messages(conversation_id, seq);
+CREATE INDEX IF NOT EXISTS idx_messages_ts ON messages(ts_ms);
+
+CREATE TABLE IF NOT EXISTS sync_state (
+  conversation_id TEXT PRIMARY KEY,
+  last_synced_seq INTEGER NOT NULL DEFAULT 0,
+  last_synced_at INTEGER
+);
+`;
+var LocalStore = class {
+  db;
+  constructor(dbPath) {
+    const p = getStorePath(dbPath);
+    const dir = path3.dirname(p);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+    }
+    this.db = new Database(p);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(SCHEMA_SQL);
+  }
+  getDb() {
+    return this.db;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/a2a-adapter.ts
+import {
+  A2AClient
+} from "@pingagent/a2a";
+var A2AAdapter = class {
+  client;
+  cachedCard = null;
+  constructor(opts) {
+    this.client = new A2AClient({
+      agentUrl: opts.agentUrl,
+      authToken: opts.authToken ? `Bearer ${opts.authToken}` : void 0,
+      timeoutMs: opts.timeoutMs
+    });
+  }
+  async getAgentCard() {
+    if (!this.cachedCard) {
+      this.cachedCard = await this.client.fetchAgentCard();
+    }
+    return this.cachedCard;
+  }
+  /**
+   * Send a task to the external A2A agent and optionally wait for completion.
+   */
+  async sendTask(opts) {
+    const parts = [];
+    parts.push({ kind: "text", text: opts.title });
+    if (opts.description) {
+      parts.push({ kind: "text", text: opts.description });
+    }
+    if (opts.input) {
+      parts.push({
+        kind: "data",
+        data: typeof opts.input === "object" ? opts.input : { value: opts.input }
+      });
+    }
+    const messageId = `msg_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const message = {
+      kind: "message",
+      messageId,
+      role: "user",
+      parts
+    };
+    if (opts.wait) {
+      const task = await this.client.sendAndWait(
+        { message, configuration: { blocking: true } },
+        { maxPollMs: opts.timeoutMs ?? 12e4 }
+      );
+      return this.convertTask(task);
+    }
+    const result = await this.client.sendMessage({ message });
+    if (result.kind === "task") {
+      return this.convertTask(result);
+    }
+    return {
+      taskId: result.messageId,
+      state: "completed",
+      summary: this.extractText(result.parts)
+    };
+  }
+  async getTaskStatus(taskId) {
+    const task = await this.client.getTask(taskId);
+    return this.convertTask(task);
+  }
+  async cancelTask(taskId) {
+    const task = await this.client.cancelTask(taskId);
+    return this.convertTask(task);
+  }
+  async sendText(text, opts) {
+    const result = await this.client.sendText(text, { blocking: opts?.blocking });
+    if (result.kind === "task") {
+      return this.convertTask(result);
+    }
+    return {
+      taskId: result.messageId,
+      state: "completed",
+      summary: this.extractText(result.parts)
+    };
+  }
+  convertTask(task) {
+    const summary = task.artifacts?.flatMap((a) => a.parts).filter((p) => p.kind === "text").map((p) => p.text).join("\n");
+    const output = task.artifacts?.flatMap((a) => a.parts).filter((p) => p.kind === "data").map((p) => p.data);
+    return {
+      taskId: task.id,
+      contextId: task.contextId,
+      state: task.status.state,
+      summary: summary || void 0,
+      output: output && output.length > 0 ? output.length === 1 ? output[0] : output : void 0,
+      timestamp: task.status.timestamp
+    };
+  }
+  extractText(parts) {
+    return parts.filter((p) => p.kind === "text").map((p) => p.text).join("\n") || void 0;
+  }
+};
+
+// src/ws-subscription.ts
+import WebSocket from "ws";
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var RECONNECT_JITTER = 0.2;
+var LIST_CONVERSATIONS_INTERVAL_MS = 6e4;
+var WsSubscription = class {
+  opts;
+  connections = /* @__PURE__ */ new Map();
+  reconnectTimers = /* @__PURE__ */ new Map();
+  reconnectAttempts = /* @__PURE__ */ new Map();
+  listInterval = null;
+  stopped = false;
+  /** Conversation IDs that were explicitly stopped (e.g. revoke); do not reconnect. */
+  stoppedConversations = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.opts = opts;
+  }
+  start() {
+    this.stopped = false;
+    this.connectAll();
+    this.listInterval = setInterval(() => this.syncConnections(), LIST_CONVERSATIONS_INTERVAL_MS);
+  }
+  stop() {
+    this.stopped = true;
+    if (this.listInterval) {
+      clearInterval(this.listInterval);
+      this.listInterval = null;
+    }
+    for (const timer of this.reconnectTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.reconnectTimers.clear();
+    for (const [convId, ws] of this.connections) {
+      ws.removeAllListeners();
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+      this.connections.delete(convId);
+    }
+    this.reconnectAttempts.clear();
+    this.stoppedConversations.clear();
+  }
+  /**
+   * Stop a single conversation's WebSocket and do not reconnect.
+   * Used when the conversation is revoked or the client no longer wants to subscribe.
+   */
+  stopConversation(conversationId) {
+    this.stoppedConversations.add(conversationId);
+    const timer = this.reconnectTimers.get(conversationId);
+    if (timer) {
+      clearTimeout(timer);
+      this.reconnectTimers.delete(conversationId);
+    }
+    const ws = this.connections.get(conversationId);
+    if (ws) {
+      ws.removeAllListeners();
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+      this.connections.delete(conversationId);
+    }
+  }
+  wsUrl(conversationId) {
+    const base = this.opts.serverUrl.replace(/^http/, "ws").replace(/\/$/, "");
+    return `${base}/v1/ws?conversation_id=${encodeURIComponent(conversationId)}`;
+  }
+  async connectAsync(conversationId) {
+    if (this.stopped || this.stoppedConversations.has(conversationId) || this.connections.has(conversationId)) return;
+    const token = await Promise.resolve(this.opts.getAccessToken());
+    const url = this.wsUrl(conversationId);
+    const ws = new WebSocket(url, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    this.connections.set(conversationId, ws);
+    ws.on("open", () => {
+      this.reconnectAttempts.set(conversationId, 0);
+      this.opts.onOpen?.(conversationId);
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "ws_message" && msg.envelope) {
+          const env = msg.envelope;
+          if (env.sender_did !== this.opts.myDid) {
+            this.opts.onMessage(env, conversationId);
+          }
+        } else if (msg.type === "ws_control" && msg.control) {
+          this.opts.onControl?.(msg.control, conversationId);
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      this.connections.delete(conversationId);
+      if (!this.stopped && !this.stoppedConversations.has(conversationId)) {
+        this.scheduleReconnect(conversationId);
+      }
+    });
+    ws.on("error", (err) => {
+      this.opts.onError?.(err);
+    });
+  }
+  scheduleReconnect(conversationId) {
+    if (this.reconnectTimers.has(conversationId)) return;
+    const attempt = this.reconnectAttempts.get(conversationId) ?? 0;
+    this.reconnectAttempts.set(conversationId, attempt + 1);
+    const tryConnect = () => {
+      this.reconnectTimers.delete(conversationId);
+      if (this.stopped) return;
+      void this.connectAsync(conversationId);
+    };
+    const delay = Math.min(
+      RECONNECT_BASE_MS * Math.pow(2, attempt) + (Math.random() - 0.5) * RECONNECT_JITTER * RECONNECT_BASE_MS,
+      RECONNECT_MAX_MS
+    );
+    const timer = setTimeout(tryConnect, delay);
+    this.reconnectTimers.set(conversationId, timer);
+  }
+  async connectAll() {
+    try {
+      const convos = await this.opts.listConversations();
+      const subscribable = convos.filter((c) => c.type === "dm" || c.type === "channel");
+      for (const c of subscribable) {
+        void this.connectAsync(c.conversation_id);
+      }
+    } catch (err) {
+      this.opts.onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  async syncConnections() {
+    if (this.stopped) return;
+    try {
+      const convos = await this.opts.listConversations();
+      const subscribableIds = new Set(
+        convos.filter((c) => c.type === "dm" || c.type === "channel").map((c) => c.conversation_id)
+      );
+      for (const convId of subscribableIds) {
+        if (!this.stoppedConversations.has(convId) && !this.connections.has(convId)) {
+          void this.connectAsync(convId);
+        }
+      }
+      for (const convId of this.connections.keys()) {
+        if (!subscribableIds.has(convId) || this.stoppedConversations.has(convId)) {
+          const ws = this.connections.get(convId);
+          if (ws) {
+            ws.removeAllListeners();
+            ws.close();
+            this.connections.delete(convId);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+export {
+  HttpTransport,
+  ContactManager,
+  HistoryManager,
+  PingAgentClient,
+  getRootDir,
+  getProfile,
+  getIdentityPath,
+  getStorePath,
+  generateIdentity,
+  identityExists,
+  loadIdentity,
+  saveIdentity,
+  updateStoredToken,
+  ensureTokenValid,
+  LocalStore,
+  A2AAdapter,
+  WsSubscription
+};