@openagents-org/agent-launcher 0.2.167 → 0.2.169

package/src/adapters/index.js

@@ -21,6 +21,7 @@ const ClineAdapter = require('./cline');
 const AmpAdapter = require('./amp');
 const MiniSweAgentAdapter = require('./mini');
 const PiAdapter = require('./pi');
+const DeepSeekAdapter = require('./deepseek');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -39,11 +40,12 @@ const ADAPTER_MAP = {
   amp: AmpAdapter,
   'mini-swe-agent': MiniSweAgentAdapter,
   pi: PiAdapter,
+  deepseek: DeepSeekAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -73,6 +75,7 @@ module.exports = {
   AmpAdapter,
   MiniSweAgentAdapter,
   PiAdapter,
+  DeepSeekAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/adapters/utils.js

@@ -52,11 +52,30 @@ function generateSessionTitle(message, maxWords = 6) {
 
 /**
  * Format attachment metadata into text to append to an agent prompt.
+ *
+ * `tokenExpr` is the SHELL EXPRESSION the agent should use for the workspace
+ * token, not the token itself. It defaults to `$TOKEN` for the adapters that
+ * already export the token under that name. An adapter whose prompt must never
+ * contain the literal token (deepseek writes its prompt to a file and exports
+ * OPENAGENTS_WORKSPACE_TOKEN into the child environment) passes its own
+ * expression instead — otherwise `$TOKEN` expands to the empty string in the
+ * child and every attachment download silently 401s.
+ *
  * @param {Array} attachments
  * @param {'mcp'|'skills'} [toolMode='mcp']
  * @param {boolean} [isWindows]
+ * @param {object} [opts]
+ * @param {string} [opts.tokenExpr='$TOKEN'] shell expression yielding the token
+ * @param {string} [opts.endpoint] base URL used when an attachment carries no
+ *   absolute `url`. Without it the fallback emits a literal `{WORKSPACE_API}`
+ *   placeholder that nothing substitutes.
  */
-function formatAttachmentsForPrompt(attachments, toolMode = 'mcp', isWindows = process.platform === 'win32') {
+function formatAttachmentsForPrompt(
+  attachments,
+  toolMode = 'mcp',
+  isWindows = process.platform === 'win32',
+  { tokenExpr = '$TOKEN', endpoint = null } = {},
+) {
   if (!attachments || attachments.length === 0) return null;
 
   const lines = ['\n[Attached files]'];
@@ -65,21 +84,22 @@ function formatAttachmentsForPrompt(attachments, toolMode = 'mcp', isWindows = p
     const fileId = att.fileId || '';
     const contentType = att.contentType || '';
     if (toolMode === 'skills') {
-      const url = att.url || `{WORKSPACE_API}/v1/files/${fileId}`;
+      const base = endpoint ? String(endpoint).replace(/\/+$/, '') : '{WORKSPACE_API}';
+      const url = att.url || `${base}/v1/files/${fileId}`;
       const curl = isWindows ? 'curl.exe' : 'curl';
       const tmpDir = isWindows ? '$env:TEMP' : '/tmp';
       if (contentType.startsWith('image/')) {
         lines.push(
           `- Image: ${filename} (file_id: ${fileId}) — ` +
           `download with curl, then use your Read tool on the local file to view it:\n` +
-          `  Step 1: ${curl} -s -H "X-Workspace-Token: $TOKEN" "${url}" -o ${tmpDir}/${filename}\n` +
+          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${filename}\n` +
           `  Step 2: Use the Read tool on ${tmpDir}/${filename} to see the image`
         );
       } else {
         lines.push(
           `- File: ${filename} (file_id: ${fileId}, type: ${contentType}) — ` +
           `download with curl, then use your Read tool on the local file:\n` +
-          `  Step 1: ${curl} -s -H "X-Workspace-Token: $TOKEN" "${url}" -o ${tmpDir}/${filename}\n` +
+          `  Step 1: ${curl} -s -H "X-Workspace-Token: ${tokenExpr}" "${url}" -o ${tmpDir}/${filename}\n` +
           `  Step 2: Use the Read tool on ${tmpDir}/${filename} to read the file`
         );
       }

package/src/adapters/workspace-prompt.js

@@ -1021,6 +1021,68 @@ function buildPiSystemPrompt({ agentName, workspaceId, channelName, endpoint, to
   return identity + directive + '\n' + collab + '\n' + modePrompt + '\n' + api + '\n' + buildGuardrails();
 }
 
+/**
+ * Build the task FILE contents for the DeepSeek Harness adapter.
+ *
+ * dsh takes its task as a positional argv element and has no stdin channel, so
+ * the adapter writes everything here to a private file and passes only a
+ * constant sentence on the command line. Two consequences shape this function:
+ *
+ *  - The workspace token must NEVER appear. `tokenExpr` is a SHELL EXPRESSION
+ *    (`$OPENAGENTS_WORKSPACE_TOKEN`, or `$env:OPENAGENTS_WORKSPACE_TOKEN` on
+ *    Windows) that the agent expands at run time from the child environment.
+ *    Passing the real token here would put it on disk for no benefit — and the
+ *    guard below makes that a loud failure rather than a silent leak.
+ *
+ *  - dsh has no session resume: each run is a fresh session. The channel recap
+ *    is therefore part of the task itself rather than something the agent can
+ *    be expected to remember.
+ */
+function buildDeepSeekTaskFile({
+  agentName, workspaceId, channelName, endpoint, tokenExpr,
+  mode = 'execute', disabledModules, browserEnabled = false,
+  recap = '', request = '', attachments = '',
+}) {
+  // A token expression is a shell reference, never a credential. Anything that
+  // does not start with `$` is almost certainly a real token passed by mistake.
+  if (!tokenExpr || !/^\$/.test(String(tokenExpr))) {
+    throw new Error(
+      'buildDeepSeekTaskFile: tokenExpr must be a shell expression such as '
+      + '$OPENAGENTS_WORKSPACE_TOKEN — never the workspace token itself.',
+    );
+  }
+
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode, 'skills');
+  const directive = buildBrowserDirective(browserEnabled);
+  const collab = buildCollaborationPrompt('skills', workspaceSkillName(agentName));
+  const modePrompt = buildModePrompt(mode);
+  const api = buildApiSkillsPrompt({
+    endpoint, workspaceId, token: tokenExpr, agentName, channelName, disabledModules, mode,
+  });
+
+  const parts = [identity, directive, '\n', collab, '\n', modePrompt, '\n', api, '\n', buildGuardrails()];
+
+  if (recap) {
+    parts.push(
+      '\n## Recent channel history\n'
+      + 'You are running as a fresh process with no memory of earlier turns. '
+      + 'This is the relevant history — treat it as context, not as new work.\n\n'
+      + recap + '\n',
+    );
+  }
+
+  parts.push(
+    '\n## Your task\n'
+    + 'Respond to the request below. Everything above is context and standing '
+    + 'instruction; only this section is what you were asked to do now.\n\n'
+    + String(request || '').trim() + '\n',
+  );
+
+  if (attachments) parts.push('\n' + attachments + '\n');
+
+  return parts.join('');
+}
+
 /**
  * Build workspace skill markdown for OpenCode (written to .opencode/skills/).
  */
@@ -1127,6 +1189,7 @@ module.exports = {
   buildOpenCodeSystemPrompt,
   buildOpenCodeSkillMd,
   buildPiSystemPrompt,
+  buildDeepSeekTaskFile,
   buildClaudeSkillMd,
   buildCursorSkillMd,
 };

package/src/installer.js

@@ -609,7 +609,12 @@ class Installer {
         env: getEnhancedEnv(),
         timeout: 10000,
       }).trim();
-      const match = raw.match(/(\d+[\d.]+\d+)/);
+      // The optional `-prerelease` tail is NOT decoration. An agent pinned to a
+      // preview release (`@deepseek-ai/dsh@0.1.0-rc.6`) is gated on the exact
+      // version, and dropping the suffix reported a correctly installed rc.6 as
+      // plain `0.1.0` — which then failed its own gate. Agents without a
+      // prerelease segment match exactly as before.
+      const match = raw.match(/(\d+[\d.]+\d+(?:-[0-9A-Za-z.-]+)?)/);
       version = match ? match[1] : (raw.split('\n')[0] || null);
     } catch {}
 
@@ -618,14 +623,52 @@ class Installer {
   }
 
   /**
-   * Evaluate `install.min_version` against a detected version. Generic for any
+   * Evaluate a registry version gate against a detected version. Generic for any
    * agent. Returns { compatible: true|false|null, minVersion, message }.
-   *   • no min_version declared → compatible:true (gate disabled)
-   *   • version unparseable      → compatible:null  ("unknown", don't false-pass)
-   *   • version < min_version    → compatible:false (block + upgrade hint)
-   *   • version >= min_version   → compatible:true
+   *
+   * Two gate shapes, in priority order:
+   *
+   *   `install.supported_version` — EXACT match. For agents pinned to an
+   *   upstream preview whose configuration can change between releases, a floor
+   *   is the wrong shape: it happily admits the next preview, which is precisely
+   *   the version the adapter has not been written against. Declared by
+   *   deepseek (dsh is a developer preview).
+   *
+   *   `install.min_version` / `check_ready.min_version` — a floor (>=). The
+   *   original behaviour, unchanged for every agent that does not declare
+   *   supported_version.
    */
   _evaluateCompatibility(entry, version) {
+    const supported = (entry && entry.install && entry.install.supported_version) || null;
+    if (supported) {
+      // Compare the version-shaped token from each side, prerelease included.
+      // `compareVersions` cannot be used: it strips `-rc.N`, so rc.5 and rc.6
+      // would compare equal and the exact gate would admit the wrong preview.
+      const norm = (v) => {
+        const m = String(v == null ? '' : v).match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+        return m ? m[0] : null;
+      };
+      const got = norm(version);
+      const want = norm(supported);
+      if (!got) {
+        return {
+          compatible: null,
+          minVersion: supported,
+          message: `Version unknown (requires exactly ${supported})`,
+        };
+      }
+      if (got !== want) {
+        return {
+          compatible: false,
+          minVersion: supported,
+          message:
+            `${(entry.label || entry.name || 'This agent')} ${got} is not supported — ` +
+            `it is pinned to ${want} exactly (upstream ships it as a developer preview).`,
+        };
+      }
+      return { compatible: true, minVersion: supported, message: null };
+    }
+
     // Opt-in floor declared under either install.min_version or
     // check_ready.min_version (e.g. cline pins check_ready.min_version).
     const minVersion = (entry && (
@@ -1326,11 +1369,18 @@ class Installer {
     // npm install -g <pkg> → npm uninstall --prefix <runtimeDir> <pkg>
     if (installCmd.includes('npm install')) {
       const prefixDir = agentType ? getRuntimePrefix(agentType) : path.join(os.homedir(), '.openagents', 'nodejs');
-      return installCmd
+      const cmd = installCmd
         .replace('npm install -g', `npm uninstall --prefix "${prefixDir}"`)
-        .replace('npm install', 'npm uninstall')
-        .replace(/@latest/g, '')
-        .replace(/@[\d.]+/g, '');
+        .replace('npm install', 'npm uninstall');
+      // Drop the version spec, whatever shape it takes. This used to be two
+      // blind global replaces — `@latest` and `@[\d.]+` — and the second one
+      // understood only digits and dots, so a PRERELEASE pin was cut in half:
+      //   @deepseek-ai/dsh@0.1.0-rc.6  →  @deepseek-ai/dsh-rc.6
+      // npm exits 0 when asked to remove a package that is not installed, so
+      // the uninstall reported success, removed nothing, and left the agent
+      // looking installed forever. Anchoring to the package token at the end of
+      // the command makes the shape of the version irrelevant.
+      return cmd.replace(/(\s@?[\w-]+(?:\/[\w-]+)?)@\S+\s*$/, '$1');
     }
 
     // pip install <pkg> → pip uninstall -y <pkg>

package/src/workspace-client.js

@@ -209,6 +209,27 @@ class WorkspaceClient {
     const payload = { content, message_type: messageType };
     if (attachments && attachments.length) payload.attachments = attachments;
 
+    // DM sessions (`dm:<counterpart address>`, created by _eventToMessage for
+    // incoming direct messages) reply as direct events to the counterpart —
+    // not into a `channel/dm:…` channel, which no client would ever read.
+    if (channelName && channelName.startsWith('dm:')) {
+      const counterpart = channelName.slice(3);
+      const meta = { ...(metadata || {}) };
+      if (!meta.target_agents) {
+        meta.target_agents = counterpart.startsWith('openagents:')
+          ? [counterpart.replace(/^openagents:/, '')]
+          : ['__no_response__'];
+      }
+      return this.sendEvent(workspaceId, {
+        type: 'workspace.message.posted',
+        source,
+        target: counterpart,
+        payload,
+        metadata: meta,
+        visibility: 'direct',
+      }, token, sessionId);
+    }
+
     return this.sendEvent(workspaceId, {
       type: 'workspace.message.posted',
       source,
@@ -841,9 +862,23 @@ class WorkspaceClient {
     const target = event.target || '';
     const ts = event.timestamp;
 
+    // Session id: channels map to their name. A direct message (visibility
+    // 'direct', target = this agent's own address) maps to a per-counterpart
+    // DM session `dm:<source address>` — so the adapter keeps one CLI session
+    // per DM peer, and sendMessage() below routes replies back as direct
+    // events to that peer instead of into a channel.
+    let sessionId;
+    if (target.startsWith('channel/')) {
+      sessionId = target.replace('channel/', '');
+    } else if (event.visibility === 'direct' && source) {
+      sessionId = `dm:${source}`;
+    } else {
+      sessionId = target;
+    }
+
     const msg = {
       messageId: event.id || '',
-      sessionId: target.startsWith('channel/') ? target.replace('channel/', '') : target,
+      sessionId,
       senderType: isHuman ? 'human' : 'agent',
       senderName,
       content: (payload.content || event.content || ''),