fix: capture reasoning signatures and strip unsigned reasoning

Root cause: Anthropic's Extended Thinking API requires thinking blocks to
include a signature for replay. The Vercel AI SDK silently drops reasoning
parts without providerOptions.anthropic.signature, which can leave assistant
messages empty and cause API rejection with 'all messages must have non-empty
content'.

Changes:
- Add signature field to MuxReasoningPart and ReasoningDeltaEvent
- Capture signatures from SDK stream events (signature_delta)
- Store providerOptions.anthropic.signature for SDK compatibility
- Add stripUnsendableReasoning() to remove reasoning without signatures
  before API calls, preventing empty messages
- Add --workspace flag to CLI for debugging existing workspaces

Author: ammar-agent

src/browser/utils/messages/ChatEventProcessor.ts

@@ -254,12 +254,27 @@ export function createChatEventProcessor(): ChatEventProcessor {
 
       const lastPart = message.parts.at(-1);
       if (lastPart?.type === "reasoning") {
-        lastPart.text += event.delta;
+        // Signature updates come with empty delta - just update the signature
+        if (event.signature && !event.delta) {
+          lastPart.signature = event.signature;
+          lastPart.providerOptions = { anthropic: { signature: event.signature } };
+        } else {
+          lastPart.text += event.delta;
+          // Also capture signature if present with text
+          if (event.signature) {
+            lastPart.signature = event.signature;
+            lastPart.providerOptions = { anthropic: { signature: event.signature } };
+          }
+        }
       } else {
         message.parts.push({
           type: "reasoning",
           text: event.delta,
           timestamp: event.timestamp,
+          signature: event.signature,
+          providerOptions: event.signature
+            ? { anthropic: { signature: event.signature } }
+            : undefined,
         });
       }
       return;

src/browser/utils/messages/modelMessageTransform.ts

@@ -490,6 +490,62 @@ function filterReasoningOnlyMessages(messages: ModelMessage[]): ModelMessage[] {
   });
 }
 
+/**
+ * Strip Anthropic reasoning parts that lack a valid signature.
+ *
+ * Anthropic's Extended Thinking API requires thinking blocks to include a signature
+ * for replay. The Vercel AI SDK's Anthropic provider only sends reasoning parts to
+ * the API if they have providerOptions.anthropic.signature. Reasoning parts we create
+ * (placeholders) or from history (where we didn't capture the signature) will be
+ * silently dropped by the SDK.
+ *
+ * If all parts of an assistant message are unsigned reasoning, the SDK drops them all,
+ * leaving an empty message that Anthropic rejects with:
+ * "all messages must have non-empty content except for the optional final assistant message"
+ *
+ * This function removes unsigned reasoning upfront and filters resulting empty messages.
+ *
+ * NOTE: This is Anthropic-specific. Other providers (e.g., OpenAI) handle reasoning
+ * differently and don't require signatures.
+ */
+function stripUnsignedAnthropicReasoning(messages: ModelMessage[]): ModelMessage[] {
+  const stripped = messages.map((msg) => {
+    if (msg.role !== "assistant") {
+      return msg;
+    }
+
+    const assistantMsg = msg;
+    if (typeof assistantMsg.content === "string") {
+      return msg;
+    }
+
+    // Filter out reasoning parts without anthropic.signature in providerOptions
+    const content = assistantMsg.content.filter((part) => {
+      if (part.type !== "reasoning") {
+        return true;
+      }
+      // Check for anthropic.signature in providerOptions
+      const anthropicMeta = (part.providerOptions as { anthropic?: { signature?: string } })
+        ?.anthropic;
+      return anthropicMeta?.signature != null;
+    });
+
+    const result: typeof assistantMsg = { ...assistantMsg, content };
+    return result;
+  });
+
+  // Filter out messages that became empty after stripping reasoning
+  return stripped.filter((msg) => {
+    if (msg.role !== "assistant") {
+      return true;
+    }
+    if (typeof msg.content === "string") {
+      return msg.content.length > 0;
+    }
+    return msg.content.length > 0;
+  });
+}
+
 /**
  * Coalesce consecutive parts of the same type within each message.
  * Streaming creates many individual text/reasoning parts; merge them for easier debugging.
@@ -540,6 +596,47 @@ function coalesceConsecutiveParts(messages: ModelMessage[]): ModelMessage[] {
   });
 }
 
+/**
+ * Merge consecutive assistant messages by combining their content arrays.
+ * This can happen when splitMixedContentMessages creates multiple assistant messages
+ * (text-only followed by tool-call-only) that are then followed by more tool operations.
+ * Anthropic API requires no two consecutive assistant messages.
+ */
+function mergeConsecutiveAssistantMessages(messages: ModelMessage[]): ModelMessage[] {
+  const merged: ModelMessage[] = [];
+
+  for (const msg of messages) {
+    if (
+      msg.role === "assistant" &&
+      merged.length > 0 &&
+      merged[merged.length - 1].role === "assistant"
+    ) {
+      // Consecutive assistant message - merge content arrays
+      const prevMsg = merged[merged.length - 1];
+      const currentMsg = msg;
+
+      // Get content arrays (handle string content by wrapping in text part)
+      const prevContent = Array.isArray(prevMsg.content)
+        ? prevMsg.content
+        : [{ type: "text" as const, text: prevMsg.content }];
+
+      const currentContent = Array.isArray(currentMsg.content)
+        ? currentMsg.content
+        : [{ type: "text" as const, text: currentMsg.content }];
+
+      // Merge content arrays - use type assertion since we're combining valid parts
+      merged[merged.length - 1] = {
+        role: "assistant",
+        content: [...prevContent, ...currentContent] as AssistantModelMessage["content"],
+      };
+    } else {
+      merged.push(msg);
+    }
+  }
+
+  return merged;
+}
+
 /**
  * Merge consecutive user messages with newline separators.
  * When filtering removes assistant messages, we can end up with consecutive user messages.
@@ -637,9 +734,10 @@ function ensureAnthropicThinkingBeforeToolCalls(messages: ModelMessage[]): Model
     }
 
     // Anthropic extended thinking requires tool-use assistant messages to start with a thinking block.
-    // If we still have no reasoning available, insert an empty reasoning part as a minimal placeholder.
+    // If we still have no reasoning available, insert a minimal placeholder reasoning part.
+    // NOTE: The text cannot be empty - Anthropic API rejects empty content.
     if (reasoningParts.length === 0) {
-      reasoningParts = [{ type: "reasoning" as const, text: "" }];
+      reasoningParts = [{ type: "reasoning" as const, text: "..." }];
     }
 
     result.push({
@@ -668,7 +766,7 @@ function ensureAnthropicThinkingBeforeToolCalls(messages: ModelMessage[]): Model
       result[i] = {
         ...assistantMsg,
         content: [
-          { type: "reasoning" as const, text: "" },
+          { type: "reasoning" as const, text: "..." },
           { type: "text" as const, text },
         ],
       };
@@ -685,7 +783,7 @@ function ensureAnthropicThinkingBeforeToolCalls(messages: ModelMessage[]): Model
 
     result[i] = {
       ...assistantMsg,
-      content: [{ type: "reasoning" as const, text: "" }, ...content],
+      content: [{ type: "reasoning" as const, text: "..." }, ...content],
     };
     break;
   }
@@ -730,7 +828,9 @@ export function transformModelMessages(
     // Anthropic: When extended thinking is enabled, preserve reasoning-only messages and ensure
     // tool-call messages start with reasoning. When it's disabled, filter reasoning-only messages.
     if (options?.anthropicThinkingEnabled) {
-      reasoningHandled = ensureAnthropicThinkingBeforeToolCalls(split);
+      // First strip reasoning without signatures (SDK will drop them anyway, causing empty messages)
+      const signedReasoning = stripUnsignedAnthropicReasoning(split);
+      reasoningHandled = ensureAnthropicThinkingBeforeToolCalls(signedReasoning);
     } else {
       reasoningHandled = filterReasoningOnlyMessages(split);
     }
@@ -739,8 +839,14 @@ export function transformModelMessages(
     reasoningHandled = split;
   }
 
-  // Pass 3: Merge consecutive user messages (applies to all providers)
-  const merged = mergeConsecutiveUserMessages(reasoningHandled);
+  // Pass 3: Merge consecutive assistant messages (applies to all providers)
+  // This can happen when splitMixedContentMessages splits text from tool calls,
+  // creating [assistant:text] [tool:result] [assistant:tools] patterns that become
+  // [assistant:text] [assistant:tools] after tool result processing.
+  const mergedAssistants = mergeConsecutiveAssistantMessages(reasoningHandled);
+
+  // Pass 4: Merge consecutive user messages (applies to all providers)
+  const merged = mergeConsecutiveUserMessages(mergedAssistants);
 
   return merged;
 }

src/cli/run.ts

@@ -195,6 +195,7 @@ program
   .option("--json", "output NDJSON for programmatic consumption")
   .option("-q, --quiet", "only output final result")
   .option("--workspace-id <id>", "explicit workspace ID (auto-generated if not provided)")
+  .option("--workspace <id>", "continue an existing workspace (loads history, skips init)")
   .option("--config-root <path>", "mux config directory")
   .option("--mcp <server>", "MCP server as name=command (can be repeated)", collectMcpServers, [])
   .option("--no-mcp-config", "ignore .mux/mcp.jsonc, use only --mcp servers")
@@ -227,6 +228,7 @@ interface CLIOptions {
   json?: boolean;
   quiet?: boolean;
   workspaceId?: string;
+  workspace?: string;
   configRoot?: string;
   mcp: MCPServerEntry[];
   mcpConfig: boolean;
@@ -250,10 +252,6 @@ async function main(): Promise<void> {
   }
   // Default is already "warn" for CLI mode (set in log.ts)
 
-  // Resolve directory
-  const projectDir = path.resolve(opts.dir);
-  await ensureDirectory(projectDir);
-
   // Get message from arg or stdin
   const stdinMessage = await gatherMessageFromStdin();
   const message = messageArg?.trim() ?? stdinMessage.trim();
@@ -266,7 +264,35 @@ async function main(): Promise<void> {
 
   // Setup config
   const config = new Config(opts.configRoot);
-  const workspaceId = opts.workspaceId ?? generateWorkspaceId();
+
+  // Determine if continuing an existing workspace
+  const continueWorkspace = opts.workspace;
+  const workspaceId = continueWorkspace ?? opts.workspaceId ?? generateWorkspaceId();
+
+  // Resolve directory - for continuing workspace, try to get from metadata
+  let projectDir: string;
+  if (continueWorkspace) {
+    const metadataPath = path.join(config.sessionsDir, continueWorkspace, "metadata.json");
+    try {
+      const metadataContent = await fs.readFile(metadataPath, "utf-8");
+      const metadata = JSON.parse(metadataContent) as { projectPath?: string };
+      if (metadata.projectPath) {
+        projectDir = metadata.projectPath;
+        log.info(`Continuing workspace ${continueWorkspace}, using project path: ${projectDir}`);
+      } else {
+        projectDir = path.resolve(opts.dir);
+        log.warn(`No projectPath in metadata, using --dir: ${projectDir}`);
+      }
+    } catch {
+      // Metadata doesn't exist or is invalid, fall back to --dir
+      projectDir = path.resolve(opts.dir);
+      log.warn(`Could not read metadata for ${continueWorkspace}, using --dir: ${projectDir}`);
+    }
+  } else {
+    projectDir = path.resolve(opts.dir);
+    await ensureDirectory(projectDir);
+  }
+
   const model: string = opts.model;
   const runtimeConfig = parseRuntimeConfig(opts.runtime, config.srcDir);
   const thinkingLevel = parseThinkingLevel(opts.thinking);
@@ -333,11 +359,17 @@ async function main(): Promise<void> {
     backgroundProcessManager,
   });
 
-  await session.ensureMetadata({
-    workspacePath: projectDir,
-    projectName: path.basename(projectDir),
-    runtimeConfig,
-  });
+  // For continuing workspace, metadata should already exist
+  // For new workspace, create it
+  if (!continueWorkspace) {
+    await session.ensureMetadata({
+      workspacePath: projectDir,
+      projectName: path.basename(projectDir),
+      runtimeConfig,
+    });
+  } else {
+    log.info(`Continuing workspace ${workspaceId} - using existing metadata`);
+  }
 
   const buildSendOptions = (cliMode: CLIMode): SendMessageOptions => ({
     model,

src/common/orpc/schemas/stream.ts

@@ -201,6 +201,10 @@ export const ReasoningDeltaEventSchema = z.object({
   delta: z.string(),
   tokens: z.number().meta({ description: "Token count for this delta" }),
   timestamp: z.number().meta({ description: "When delta was received (Date.now())" }),
+  signature: z
+    .string()
+    .optional()
+    .meta({ description: "Anthropic thinking block signature for replay" }),
 });
 
 export const ReasoningEndEventSchema = z.object({

src/common/types/message.ts

@@ -146,6 +146,24 @@ export interface MuxReasoningPart {
   type: "reasoning";
   text: string;
   timestamp?: number;
+  /**
+   * Anthropic thinking block signature for replay.
+   * Required to send reasoning back to Anthropic - the API validates signatures
+   * to ensure thinking blocks haven't been tampered with. Reasoning without
+   * signatures will be stripped before sending to avoid "empty content" errors.
+   */
+  signature?: string;
+  /**
+   * Provider options for SDK compatibility.
+   * When converting to ModelMessages via the SDK's convertToModelMessages,
+   * this is passed through. For Anthropic thinking blocks, this should contain
+   * { anthropic: { signature } } to allow reasoning replay.
+   */
+  providerOptions?: {
+    anthropic?: {
+      signature?: string;
+    };
+  };
 }
 
 // File/Image part type for multimodal messages (matches AI SDK FileUIPart)

src/node/services/streamManager.ts

@@ -49,6 +49,13 @@ globalThis.AI_SDK_LOG_WARNINGS = false;
 interface ReasoningDeltaPart {
   type: "reasoning-delta";
   text?: string;
+  delta?: string;
+  providerMetadata?: {
+    anthropic?: {
+      signature?: string;
+      redactedData?: string;
+    };
+  };
 }
 
 // Branded types for compile-time safety
@@ -480,6 +487,7 @@ export class StreamManager extends EventEmitter {
         delta: part.text,
         tokens,
         timestamp,
+        signature: part.signature,
       });
     } else if (part.type === "dynamic-tool") {
       const inputText = JSON.stringify(part.input);
@@ -926,18 +934,45 @@ export class StreamManager extends EventEmitter {
 
           case "reasoning-delta": {
             // Both Anthropic and OpenAI use reasoning-delta for streaming reasoning content
-            const delta = (part as ReasoningDeltaPart).text ?? "";
+            const reasoningPart = part as ReasoningDeltaPart;
+            const delta = reasoningPart.text ?? reasoningPart.delta ?? "";
+            const signature = reasoningPart.providerMetadata?.anthropic?.signature;
+
+            // Signature deltas come separately with empty text - attach to last reasoning part
+            if (signature && !delta) {
+              const lastPart = streamInfo.parts.at(-1);
+              if (lastPart?.type === "reasoning") {
+                lastPart.signature = signature;
+                // Also set providerOptions for SDK compatibility when converting to ModelMessages
+                lastPart.providerOptions = { anthropic: { signature } };
+                // Emit signature update event
+                this.emit("reasoning-delta", {
+                  type: "reasoning-delta",
+                  workspaceId: workspaceId as string,
+                  messageId: streamInfo.messageId,
+                  delta: "",
+                  tokens: 0,
+                  timestamp: Date.now(),
+                  signature,
+                });
+                void this.schedulePartialWrite(workspaceId, streamInfo);
+              }
+              break;
+            }
 
             // Append each delta as a new part (merging happens at display time)
-            const reasoningPart = {
+            // Include providerOptions for SDK compatibility when converting to ModelMessages
+            const newPart = {
               type: "reasoning" as const,
               text: delta,
               timestamp: Date.now(),
+              signature, // May be undefined, will be filled by subsequent signature delta
+              providerOptions: signature ? { anthropic: { signature } } : undefined,
             };
-            streamInfo.parts.push(reasoningPart);
+            streamInfo.parts.push(newPart);
 
             // Emit using shared logic (ensures replay consistency)
-            await this.emitPartAsEvent(workspaceId, streamInfo.messageId, reasoningPart);
+            await this.emitPartAsEvent(workspaceId, streamInfo.messageId, newPart);
 
             void this.schedulePartialWrite(workspaceId, streamInfo);
             break;