@openagents-org/agent-launcher 0.2.193 → 0.2.195

package/src/tools-v11/presence-handoff.js

@@ -0,0 +1,199 @@
+'use strict';
+/**
+ * Roadmap v1.1 M3/M6 — presence detail + structured agent-to-agent hand-off.
+ *
+ *   workspace_agent_availability  is <agent> free / busy / offline / runtime down?
+ *   workspace_handoff             hand work to another agent with request, context,
+ *                                 output so far and next owner travelling together
+ *   workspace_get_handoffs        the recent hand-offs in a thread
+ *
+ * A hand-off is an ordinary `workspace.message.posted` chat message that
+ * OPENS with `@<to_agent>` (the backend's deterministic explicit-target path:
+ * it routes to exactly that agent and adds it to the thread) and carries the
+ * structured record twice — `payload.handoff` for readers of the thread and
+ * `metadata.handoff` for routing/analytics — so nothing depends on parsing
+ * the markdown back out.
+ */
+
+const MAX_HANDOFFS = 10;
+
+const defs = [
+  {
+    name: 'workspace_agent_availability',
+    description:
+      'Check whether another agent can take work right now. Returns its status, whether it is busy ' +
+      '(and in which threads / how many messages are queued), whether the device it runs on is ' +
+      'online, and one reason: available | busy | agent_offline | runtime_offline.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agent: { type: 'string', description: 'Agent name (without the openagents: prefix)' },
+      },
+      required: ['agent'],
+    },
+  },
+  {
+    name: 'workspace_handoff',
+    description:
+      'Hand a piece of work to another agent in the current thread. Posts "@<to_agent> <request>" with ' +
+      'optional Context / Output so far / Next owner sections so the request, what it needs, what you ' +
+      'already produced and who owns the next step travel together. Only the addressed agent is woken. ' +
+      'Use workspace_agent_availability first if timing matters.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to_agent: { type: 'string', description: 'Agent to hand the work to (name only)' },
+        request: { type: 'string', description: 'What you are asking the agent to do — one or two sentences' },
+        context: { type: 'string', description: 'Background the agent needs (inputs, constraints, links, file ids)' },
+        output: { type: 'string', description: 'What you have already produced (results, paths, partial work)' },
+        next_owner: { type: 'string', description: 'Who owns the next step after this (defaults to to_agent)' },
+      },
+      required: ['to_agent', 'request'],
+    },
+  },
+  {
+    name: 'workspace_get_handoffs',
+    description:
+      'List the most recent structured hand-offs in a thread (newest first, max 10): who handed what to ' +
+      'whom, with the context, output and next owner they carried. Defaults to the current thread.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: 'Thread name; omit for the current one' },
+        limit: { type: 'integer', description: 'How many to return (1-10, default 10)' },
+      },
+    },
+  },
+];
+
+function cleanName(name) {
+  return String(name || '').trim().replace(/^@/, '').replace(/^openagents:/, '');
+}
+
+function cleanText(v, max) {
+  if (v === undefined || v === null) return null;
+  const s = String(v).trim();
+  if (!s) return null;
+  return max && s.length > max ? s.slice(0, max) + '…' : s;
+}
+
+/**
+ * Build the hand-off record + message content. Pure; exported for tests.
+ * Returns { handoff, content } where handoff =
+ *   { from, to, request, context, output, next_owner }.
+ */
+function buildHandoff(from, { to_agent, request, context, output, next_owner } = {}) {
+  const to = cleanName(to_agent);
+  const req = cleanText(request, 4000);
+  if (!to) throw new Error('to_agent is required');
+  if (!req) throw new Error('request is required');
+  const handoff = {
+    from: cleanName(from),
+    to,
+    request: req,
+    context: cleanText(context, 8000),
+    output: cleanText(output, 8000),
+    next_owner: cleanName(next_owner) || to,
+  };
+  let content = `@${to} ${req}`;
+  if (handoff.context) content += `\n\nContext:\n${handoff.context}`;
+  if (handoff.output) content += `\n\nOutput so far:\n${handoff.output}`;
+  content += `\n\nNext owner: ${handoff.next_owner}`;
+  return { handoff, content };
+}
+
+/** The hand-off records found in a list of raw events (newest first). */
+function extractHandoffs(events, limit = MAX_HANDOFFS) {
+  const out = [];
+  for (const e of events || []) {
+    const payload = e.payload || {};
+    const meta = e.metadata || {};
+    const h = (payload.handoff && typeof payload.handoff === 'object') ? payload.handoff
+      : (meta.handoff && typeof meta.handoff === 'object') ? meta.handoff : null;
+    if (!h) continue;
+    out.push({
+      id: e.id || null,
+      timestamp: e.timestamp || null,
+      from: h.from || String(e.source || '').replace(/^openagents:/, ''),
+      to: h.to || null,
+      request: h.request || null,
+      context: h.context || null,
+      output: h.output || null,
+      next_owner: h.next_owner || h.to || null,
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+function describeAvailability(agent, a) {
+  const bits = [`${agent}: ${a.reason || 'unknown'}`];
+  bits.push(`status=${a.status || '?'}`);
+  if (a.presence_state) bits.push(`presence=${a.presence_state}`);
+  if (Array.isArray(a.busy_channels) && a.busy_channels.length) bits.push(`busy in: ${a.busy_channels.join(', ')}`);
+  if (a.queue_depth) bits.push(`queued: ${a.queue_depth}`);
+  if (a.runtime_status) bits.push(`runtime ${a.runtime_status}${a.runtime_name ? ` (${a.runtime_name})` : ''}`);
+  const hint = {
+    available: 'It can take work now.',
+    busy: 'It will answer after the current run — a hand-off is queued, not lost.',
+    agent_offline: 'Its connector is not running; a message will wait until it reconnects.',
+    runtime_offline: 'The device it runs on is offline; nobody will pick this up until it is back.',
+  }[a.reason];
+  return bits.join(' · ') + (hint ? `\n${hint}` : '');
+}
+
+async function handle(server, name, args, helpers) {
+  const { text } = helpers;
+  args = args || {};
+  switch (name) {
+    case 'workspace_agent_availability': {
+      const agent = cleanName(args.agent);
+      if (!agent) throw new Error('agent is required');
+      const a = await server.ws.getAgentAvailability(server.workspaceId, server.token, agent);
+      return text(describeAvailability(agent, a || {}));
+    }
+
+    case 'workspace_handoff': {
+      const { handoff, content } = buildHandoff(server.agentName, args);
+      if (handoff.to === handoff.from) throw new Error('You cannot hand work to yourself');
+      const event = {
+        type: 'workspace.message.posted',
+        source: `openagents:${server.agentName}`,
+        target: `channel/${server.channelName}`,
+        payload: { content, message_type: 'chat', handoff },
+        metadata: { handoff, explicit_targets: [handoff.to] },
+      };
+      if (server.requesterEmail) event.metadata.requester_email = server.requesterEmail;
+      const result = await server.ws.sendEvent(server.workspaceId, event, server.token);
+      const targets = (result && result.metadata && result.metadata.target_agents) || [];
+      const delivered = targets.includes(handoff.to);
+      return text(
+        `Handed off to @${handoff.to}${delivered ? '' : ' (warning: the workspace did not route it — is that agent in this workspace?)'}. ` +
+        `Next owner: ${handoff.next_owner}. End your turn now unless you have other work; ` +
+        `@${handoff.to} will reply in this thread.`,
+      );
+    }
+
+    case 'workspace_get_handoffs': {
+      const channel = args.channel || server.channelName;
+      const limit = Math.min(Math.max(1, parseInt(args.limit, 10) || MAX_HANDOFFS), MAX_HANDOFFS);
+      const events = await server.ws.getChannelEvents(server.workspaceId, channel, server.token, { limit: 200, sort: 'desc' });
+      const handoffs = extractHandoffs(events, limit);
+      if (!handoffs.length) return text(`No hand-offs in ${channel} yet.`);
+      const lines = handoffs.map((h, i) => {
+        const parts = [`${i + 1}. ${h.from || '?'} → ${h.to || '?'}: ${h.request || ''}`];
+        if (h.context) parts.push(`   Context: ${h.context}`);
+        if (h.output) parts.push(`   Output so far: ${h.output}`);
+        if (h.next_owner) parts.push(`   Next owner: ${h.next_owner}`);
+        if (h.timestamp) parts.push(`   at ${new Date(h.timestamp).toISOString()}`);
+        return parts.join('\n');
+      });
+      return text(`Hand-offs in ${channel} (newest first):\n${lines.join('\n')}`);
+    }
+
+    default:
+      return undefined;
+  }
+}
+
+module.exports = { defs, handle, buildHandoff, extractHandoffs };

package/src/workspace-client.js

@@ -41,6 +41,30 @@ class SessionRevokedError extends Error {
   }
 }
 
+/**
+ * Reject when a response is cut off after its headers arrived.
+ *
+ * Node reports that on the RESPONSE, and nowhere else: once a response
+ * exists the request emits no 'error' for a connection that closes early,
+ * 'end' only fires for a complete body, and the request's abort signal is a
+ * no-op by then because the socket is already gone. A request helper that
+ * listens for 'end' alone therefore never settles — and each poll loop is a
+ * single await, so one truncated response (a backend restart mid-reply is
+ * enough) silences that loop for the life of the daemon. When it is the
+ * control poller the agent keeps working and answering, and ignores Stop.
+ */
+function rejectOnTruncatedResponse(res, reject) {
+  res.on('error', reject);
+  res.on('close', () => {
+    if (res.complete) return;
+    // Same code Node puts on the 'error' above, so callers count either as
+    // the network blip it is.
+    const err = new Error('Response ended before it was complete');
+    err.code = 'ECONNRESET';
+    reject(err);
+  });
+}
+
 /**
  * HTTP client for workspace API operations.
  *
@@ -48,8 +72,34 @@ class SessionRevokedError extends Error {
  * auth headers (X-Workspace-Token), same request/response shapes.
  */
 class WorkspaceClient {
-  constructor(endpoint) {
+  /**
+   * @param {string} [endpoint]
+   * @param {{ agentName?: string }} [opts] — when the client acts for ONE
+   *   agent, pass its name: every request then carries `X-Agent-Name` so the
+   *   workspace can apply that agent's permissions (permission model v1.1 §3)
+   *   instead of treating the call as an anonymous machine. Machine-level
+   *   clients (daemon device heartbeat, pairing redeem, workspace removal)
+   *   pass nothing and send no agent identity.
+   */
+  constructor(endpoint, { agentName } = {}) {
     this.endpoint = (endpoint || DEFAULT_ENDPOINT).replace(/\/$/, '');
+    this.agentName = typeof agentName === 'string' && agentName.trim() ? agentName.trim() : null;
+  }
+
+  /** A client for the same endpoint that acts as `agentName` (or none). */
+  withAgent(agentName) {
+    return new WorkspaceClient(this.endpoint, { agentName });
+  }
+
+  /**
+   * Request headers + the agent identity header. Applied in every transport
+   * helper (_get/_getRaw/_post/_put/_patch/_delete) so no call site can forget
+   * it. Returns a copy — callers' header objects are never mutated.
+   */
+  _withAgent(headers) {
+    const out = { ...(headers || {}) };
+    if (this.agentName && !out['X-Agent-Name']) out['X-Agent-Name'] = this.agentName;
+    return out;
   }
 
   /**
@@ -217,16 +267,80 @@ class WorkspaceClient {
    *   If the server's current session for this agent differs, _post()
    *   throws SessionRevokedError and the caller should stop its adapter.
    */
-  async heartbeat(workspaceId, agentName, token, sessionId) {
+  async heartbeat(workspaceId, agentName, token, sessionId, presence) {
     const body = {
       agent_name: agentName,
       network: workspaceId,
     };
     if (sessionId) body.session_id = sessionId;
+    // v1.1 M3 — busy/queued detail ({ presence_state, busy_channels,
+    // queue_depth }, see BaseAdapter.buildPresenceFields). Optional so older
+    // callers keep sending the legacy body.
+    if (presence && typeof presence === 'object') {
+      if (presence.presence_state !== undefined) body.presence_state = presence.presence_state;
+      if (Array.isArray(presence.busy_channels)) body.busy_channels = presence.busy_channels;
+      if (Number.isFinite(presence.queue_depth)) body.queue_depth = presence.queue_depth;
+    }
     const data = await this._post('/v1/heartbeat', body, this._wsHeaders(token));
     return data.data || data;
   }
 
+  // ── Agent profile / presence (v1.1 M3/M4) ────────────────────────────────
+
+  /** GET /v1/agents/{agent}/availability → { status, presence_state,
+   * busy_channels, queue_depth, runtime_status, runtime_name, reason }. */
+  async getAgentAvailability(workspaceId, token, agentName) {
+    const data = await this._get(
+      `/v1/agents/${encodeURIComponent(agentName)}/availability?network=${encodeURIComponent(workspaceId)}`,
+      this._wsHeaders(token),
+    );
+    return data.data || data;
+  }
+
+  /** GET /v1/agents/{agent}/profile — the specialist card. */
+  async getAgentProfile(workspaceId, token, agentName) {
+    const data = await this._get(
+      `/v1/agents/${encodeURIComponent(agentName)}/profile?network=${encodeURIComponent(workspaceId)}`,
+      this._wsHeaders(token),
+    );
+    return data.data || data;
+  }
+
+  /**
+   * GET /v1/agents/{agent}/shared-context — what THIS agent's run may use when
+   * the request comes from a teammate rather than its owner. Machine-only.
+   * Returns { apply, owner_email, requester_email, shared_instructions,
+   * allowed_knowledge: [{ slug, title, content }], cost_owner }.
+   */
+  async getSharedContext(workspaceId, token, agentName, { requesterEmail, channel, timeout } = {}) {
+    const params = new URLSearchParams({ network: workspaceId });
+    if (requesterEmail) params.set('requester_email', requesterEmail);
+    if (channel) params.set('channel', channel);
+    const data = await this._get(
+      `/v1/agents/${encodeURIComponent(agentName)}/shared-context?${params}`,
+      this._wsHeaders(token),
+      timeout || 5000,
+    );
+    return data.data || data;
+  }
+
+  /**
+   * Raw message events of a channel (newest first by default) — for callers
+   * that need payload/metadata fields _eventToMessage drops (e.g. hand-offs).
+   */
+  async getChannelEvents(workspaceId, channelName, token, { limit = 100, sort = 'desc' } = {}) {
+    const params = new URLSearchParams({
+      network: workspaceId,
+      channel: channelName,
+      type: 'workspace.message',
+      sort,
+      limit: String(Math.min(Math.max(1, limit), 500)),
+    });
+    const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+    const result = data.data || data;
+    return (result && result.events) || [];
+  }
+
   /**
    * Disconnect agent via POST /v1/leave. Best-effort (ignores errors).
    */
@@ -323,7 +437,7 @@ class WorkspaceClient {
    * previous session fails (the channel's chat history is the only thing
    * that survives a session-storage rotation).
    */
-  async getRecentMessages(workspaceId, channelName, token, limit = 30, { sort = 'desc' } = {}) {
+  async getRecentMessages(workspaceId, channelName, token, limit = 30, { sort = 'desc', before, timeout, throwOnError = false } = {}) {
     try {
       const params = new URLSearchParams({
         network: workspaceId,
@@ -332,14 +446,16 @@ class WorkspaceClient {
         sort,
         limit: String(limit),
       });
-      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+      if (before) params.set('before', before);
+      const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token), timeout);
       const result = data.data || data;
       const events = (result && result.events) || [];
       // A desc window arrives newest-first; reverse so the caller always gets
       // chronological order. An asc window is already chronological.
       const ordered = sort === 'asc' ? events.slice() : events.slice().reverse();
       return ordered.map((e) => this._eventToMessage(e));
-    } catch {
+    } catch (error) {
+      if (throwOnError) throw error;
       return [];
     }
   }
@@ -587,8 +703,17 @@ class WorkspaceClient {
   /**
    * Upload a file via POST /v1/files/base64.
    */
+  async publishWebProject(workspaceId, token, project, projectId) {
+    const body = { ...project, network: workspaceId };
+    const route = '/v1/web-projects' + (projectId ? '/' + encodeURIComponent(projectId) : '');
+    const data = projectId
+      ? await this._put(route, body, this._wsHeaders(token), 60000)
+      : await this._post(route, body, this._wsHeaders(token), 60000);
+    return data.data || data;
+  }
+
   async uploadFile(workspaceId, token, filename, contentBase64, {
-    contentType = 'application/octet-stream', source = 'human:user', channelName,
+    contentType = 'application/octet-stream', source = 'human:user', channelName, visibility,
   } = {}) {
     const body = {
       filename,
@@ -598,6 +723,7 @@ class WorkspaceClient {
       source,
     };
     if (channelName) body.channel_name = channelName;
+    if (visibility) body.visibility = visibility;
 
     const data = await this._post('/v1/files/base64', body, this._wsHeaders(token), 60000);
     return data.data || data;
@@ -675,8 +801,8 @@ class WorkspaceClient {
   /**
    * Open a new browser tab via POST /v1/browser/tabs.
    */
-  async browserOpenTab(workspaceId, token, { url = 'about:blank', source = 'human:user', context_id } = {}) {
-    const body = { url, network: workspaceId, source };
+  async browserOpenTab(workspaceId, token, { url = 'about:blank', source = 'human:user', context_id, channel } = {}) {
+    const body = { url, network: workspaceId, source, channel };
     if (context_id) body.context_id = context_id;
     const data = await this._post('/v1/browser/tabs', body, this._wsHeaders(token));
     return data.data || data;
@@ -694,24 +820,24 @@ class WorkspaceClient {
   /**
    * Navigate a browser tab via POST /v1/browser/tabs/{tabId}/navigate.
    */
-  async browserNavigate(workspaceId, token, tabId, url) {
-    const data = await this._post(`/v1/browser/tabs/${tabId}/navigate`, { url }, this._wsHeaders(token));
+  async browserNavigate(workspaceId, token, tabId, url, { source, channel } = {}) {
+    const data = await this._post(`/v1/browser/tabs/${tabId}/navigate`, { url, source, channel }, this._wsHeaders(token));
     return data.data || data;
   }
 
   /**
    * Click an element via POST /v1/browser/tabs/{tabId}/click.
    */
-  async browserClick(workspaceId, token, tabId, selector) {
-    const data = await this._post(`/v1/browser/tabs/${tabId}/click`, { selector }, this._wsHeaders(token));
+  async browserClick(workspaceId, token, tabId, selector, { source, channel } = {}) {
+    const data = await this._post(`/v1/browser/tabs/${tabId}/click`, { selector, source, channel }, this._wsHeaders(token));
     return data.data || data;
   }
 
   /**
    * Type text via POST /v1/browser/tabs/{tabId}/type.
    */
-  async browserType(workspaceId, token, tabId, selector, text) {
-    const data = await this._post(`/v1/browser/tabs/${tabId}/type`, { selector, text }, this._wsHeaders(token));
+  async browserType(workspaceId, token, tabId, selector, text, { source, channel } = {}) {
+    const data = await this._post(`/v1/browser/tabs/${tabId}/type`, { selector, text, source, channel }, this._wsHeaders(token));
     return data.data || data;
   }
 
@@ -719,16 +845,22 @@ class WorkspaceClient {
    * Get screenshot via GET /v1/browser/tabs/{tabId}/screenshot.
    * @returns {Buffer}
    */
-  async browserScreenshot(workspaceId, token, tabId) {
-    return this._getRaw(`/v1/browser/tabs/${tabId}/screenshot`, this._wsHeaders(token), 30000);
+  async browserScreenshot(workspaceId, token, tabId, { source, channel } = {}) {
+    const query = new URLSearchParams();
+    if (source) query.set('source', source);
+    if (channel) query.set('channel', channel);
+    return this._getRaw(`/v1/browser/tabs/${tabId}/screenshot?${query}`, this._wsHeaders(token), 30000);
   }
 
   /**
    * Get accessibility snapshot via GET /v1/browser/tabs/{tabId}/snapshot.
    * @returns {string}
    */
-  async browserSnapshot(workspaceId, token, tabId) {
-    const buf = await this._getRaw(`/v1/browser/tabs/${tabId}/snapshot`, this._wsHeaders(token));
+  async browserSnapshot(workspaceId, token, tabId, { source, channel } = {}) {
+    const query = new URLSearchParams();
+    if (source) query.set('source', source);
+    if (channel) query.set('channel', channel);
+    const buf = await this._getRaw(`/v1/browser/tabs/${tabId}/snapshot?${query}`, this._wsHeaders(token));
     return buf.toString('utf-8');
   }
 
@@ -943,11 +1075,25 @@ class WorkspaceClient {
       sessionId,
       senderType: isHuman ? 'human' : 'agent',
       senderName,
+      senderDisplayName: payload.sender_display_name || (event.metadata || {}).sender_display_name || null,
       content: (payload.content || event.content || ''),
       mentions: payload.mentions || [],
       messageType: payload.message_type || 'chat',
       metadata: event.metadata || {},
     };
+    // The person behind a human message (v1.1): mobile puts it in the
+    // payload, the Launcher in metadata, the web app uses its email as the
+    // sender id. Used to fetch the owner-reviewed shared context for a
+    // teammate's request and to tell the owner who asked.
+    if (isHuman) {
+      const meta = event.metadata || {};
+      const email = [payload.sender_email, meta.sender_email, payload.sender_id]
+        .find((v) => typeof v === 'string' && /^[^\s@]+@[^\s@]+$/.test(v.trim()));
+      if (email) msg.senderEmail = email.trim().toLowerCase();
+    }
+    if (payload.handoff && typeof payload.handoff === 'object') {
+      msg.handoff = payload.handoff;
+    }
     if (ts) {
       msg.createdAt = new Date(ts).toISOString();
     }
@@ -957,6 +1103,60 @@ class WorkspaceClient {
     return msg;
   }
 
+  // ── Approvals ─────────────────────────────────────────────────────────────
+
+  /** File an approval request (POST /v1/approvals). Returns the record; its
+   * `status` may already be approved/rejected when policy auto-decided. */
+  async createApproval(workspaceId, token, {
+    channel, kind, action, details, risk, source, assignee_email, requester_email,
+  } = {}) {
+    const body = {
+      network: workspaceId,
+      channel,
+      kind: kind || 'other',
+      action,
+      source: source || 'openagents:unknown',
+    };
+    if (details) body.details = String(details).slice(0, 4000);
+    if (risk) body.risk = risk;
+    if (assignee_email) body.assignee_email = assignee_email;
+    if (requester_email) body.requester_email = requester_email;
+    const data = await this._post('/v1/approvals', body, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  async getApproval(workspaceId, token, approvalId) {
+    const params = new URLSearchParams({ network: workspaceId });
+    const data = await this._get(`/v1/approvals/${encodeURIComponent(approvalId)}?${params}`, this._wsHeaders(token));
+    return data.data || data;
+  }
+
+  // ── Work brief (v1.1 M5) ──────────────────────────────────────────────────
+
+  /** Read a thread's shared work brief (GET /v1/channels/{channel}/brief).
+   * Empty fields come back null / [] when nothing has been written yet. */
+  async getBrief(workspaceId, token, channelName) {
+    const params = new URLSearchParams({ network: workspaceId });
+    const data = await this._get(
+      `/v1/channels/${encodeURIComponent(channelName)}/brief?${params}`,
+      this._wsHeaders(token),
+    );
+    return data.data || data;
+  }
+
+  /** Partial upsert of a thread's brief (PUT /v1/channels/{channel}/brief).
+   * Only the keys present in `fields` change; `source` is recorded as the
+   * writer ("openagents:<agent>"). */
+  async putBrief(workspaceId, token, channelName, fields = {}, { source } = {}) {
+    const body = { network: workspaceId, source: source || 'openagents:unknown', ...fields };
+    const data = await this._put(
+      `/v1/channels/${encodeURIComponent(channelName)}/brief`,
+      body,
+      this._wsHeaders(token),
+    );
+    return data.data || data;
+  }
+
   _wsHeaders(token) {
     return {
       'Content-Type': 'application/json',
@@ -965,6 +1165,7 @@ class WorkspaceClient {
   }
 
   _get(urlPath, headers = {}, timeout = 15000) {
+    headers = this._withAgent(headers);
     const fullUrl = this.endpoint + urlPath;
 
     return new Promise((resolve, reject) => {
@@ -985,6 +1186,7 @@ class WorkspaceClient {
         signal: AbortSignal.timeout(timeout),
       }, (res) => {
         let data = '';
+        rejectOnTruncatedResponse(res, reject);
         res.on('data', (chunk) => { data += chunk; });
         res.on('end', () => {
           try {
@@ -1014,6 +1216,7 @@ class WorkspaceClient {
   }
 
   _getRaw(urlPath, headers = {}, timeout = 15000) {
+    headers = this._withAgent(headers);
     const fullUrl = this.endpoint + urlPath;
 
     return new Promise((resolve, reject) => {
@@ -1027,6 +1230,7 @@ class WorkspaceClient {
         signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         const chunks = [];
+        rejectOnTruncatedResponse(res, reject);
         res.on('data', (chunk) => { chunks.push(chunk); });
         res.on('end', () => {
           const buf = Buffer.concat(chunks);
@@ -1045,6 +1249,7 @@ class WorkspaceClient {
   }
 
   _post(urlPath, body, headers = {}, timeout = 30000) {
+    headers = this._withAgent(headers);
     if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
     const jsonBody = JSON.stringify(body);
     const fullUrl = this.endpoint + urlPath;
@@ -1060,6 +1265,7 @@ class WorkspaceClient {
         signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
+        rejectOnTruncatedResponse(res, reject);
         res.on('data', (chunk) => { data += chunk; });
         res.on('end', () => {
           try {
@@ -1096,6 +1302,7 @@ class WorkspaceClient {
   }
 
   _put(urlPath, body, headers = {}, timeout = 30000) {
+    headers = this._withAgent(headers);
     if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
     const jsonBody = JSON.stringify(body);
     const fullUrl = this.endpoint + urlPath;
@@ -1111,6 +1318,7 @@ class WorkspaceClient {
         signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
+        rejectOnTruncatedResponse(res, reject);
         res.on('data', (chunk) => { data += chunk; });
         res.on('end', () => {
           try {
@@ -1139,6 +1347,7 @@ class WorkspaceClient {
   }
 
   _patch(urlPath, body, headers = {}, timeout = 15000) {
+    headers = this._withAgent(headers);
     if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
     const jsonBody = JSON.stringify(body);
     const fullUrl = this.endpoint + urlPath;
@@ -1154,6 +1363,7 @@ class WorkspaceClient {
         signal: AbortSignal.timeout(timeout), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
+        rejectOnTruncatedResponse(res, reject);
         res.on('data', (chunk) => { data += chunk; });
         res.on('end', () => {
           try {
@@ -1177,6 +1387,7 @@ class WorkspaceClient {
   }
 
   _delete(urlPath, headers = {}, network) {
+    headers = this._withAgent(headers);
     const fullUrl = this.endpoint + urlPath + (network ? `?network=${network}` : '');
 
     return new Promise((resolve, reject) => {
@@ -1190,6 +1401,7 @@ class WorkspaceClient {
         signal: AbortSignal.timeout(15000), // hard deadline (covers DNS/connect); see _get
       }, (res) => {
         let data = '';
+        rejectOnTruncatedResponse(res, reject);
         res.on('data', (chunk) => { data += chunk; });
         res.on('end', () => {
           try {