npm - crewly - Versions diffs - 1.20.35 → 1.20.40 - Mend

crewly 1.20.35 → 1.20.40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (77) hide show

package/frontend/dist/index.html CHANGED Viewed

@@ -7,7 +7,7 @@
     <meta name="color-scheme" content="dark" />
     <!-- Nunito font is self-hosted via @fontsource/nunito (imported in main.tsx) -->
     <title>Crewly AI Studio</title>
-    <script type="module" crossorigin src="/assets/index-e079a375.js"></script>
+    <script type="module" crossorigin src="/assets/index-e7785269.js"></script>
     <link rel="stylesheet" href="/assets/index-159eab4f.css">
   </head>
   <body class="bg-background-dark font-display text-text-primary-dark">

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "crewly",
-  "version": "1.20.35",
+  "version": "1.20.40",
   "type": "module",
   "description": "Multi-agent orchestration platform for AI coding teams — coordinates Claude Code, Gemini CLI, and Codex agents with a real-time web dashboard",
   "workspaces": [

package/packages/crewly-agent/src/runtime/agent-runner.service.test.ts CHANGED Viewed

@@ -55,9 +55,18 @@ describe('AgentRunnerService', () => {
     it('should initialize conversation state with empty messages', () => {
       const state = runner.getState();
       expect(state.messages).toEqual([]);
-      expect(state.systemPrompt).toBe('You are a test agent.');
+      expect(state.systemPrompt).toContain('You are a test agent.');
       expect(state.totalTokens).toEqual({ input: 0, output: 0 });
     });
+    it('appends the harness rules to every role prompt, so a weak model is told how to work', () => {
+      const prompt = runner.getState().systemPrompt;
+      expect(prompt.indexOf('You are a test agent.')).toBeLessThan(prompt.indexOf('## How to work'));
+      expect(prompt).toMatch(/never write a tool invocation as text/i);
+      expect(prompt).toMatch(/do the work in this turn/i);
+      // Naming the markup is what teaches a model to emit it.
+      expect(prompt).not.toMatch(/<\s*\/?\s*(invoke|parameter|function_calls)/i);
+    });
   });
   describe('initialize', () => {

package/packages/crewly-agent/src/runtime/agent-runner.service.ts CHANGED Viewed

@@ -15,6 +15,7 @@ import { createTools } from './tool-registry.js';
 import { connectAndLoadMcpTools } from './mcp-tool-bridge.js';
 import { ApprovalQueueService, type PendingApproval } from './approval-queue.service.js';
 import { OutputFilterService } from './output-filter.service.js';
+import { parseTextToolCalls, coerceArgs, resolveToolName, type TextToolCall, type SchemaLike } from './text-tool-calls.js';
 import type { ToolDefinition, McpClientLike } from './types.js';
 import {
   type CrewlyAgentConfig,
@@ -482,6 +483,25 @@ export class AgentRunnerService {
    * @param modelManager - Optional model manager instance (for testing)
    * @param apiClient - Optional API client instance (for testing)
    */
+  /**
+   * Rules about *how* to work that every role prompt gets, whatever the model.
+   *
+   * These exist because a weaker model fails in ways a strong one does not:
+   * it writes its tool call as prose (so nothing runs and the user sees
+   * markup), or it narrates a plan and stops without carrying it out. The
+   * runtime recovers from both, but saying so plainly costs a few tokens and
+   * prevents most of it. The wording deliberately never shows the markup
+   * syntax — describing it is what teaches a model to emit it.
+   */
+  private static readonly HARNESS_RULES = [
+    '## How to work',
+    '',
+    '- Call tools through the tool-calling mechanism. Never write a tool invocation as text: your text is shown to the user verbatim and executes nothing.',
+    '- Do the work in this turn. If you say you will do something, do it before you finish — a plan with no action is a failed turn.',
+    '- Act, then check. Run the tool, read the result, and continue from what it actually returned rather than from what you expected.',
+    '- If something blocks you, say what blocked you and what you tried. Never report work as done that you did not verify.',
+  ].join('\n');
   constructor(
     config: CrewlyAgentConfig,
     modelManager?: ModelManager,
@@ -495,9 +515,10 @@ export class AgentRunnerService {
     );
     this.securityPolicy = { ...CREWLY_AGENT_DEFAULTS.SECURITY_POLICY };
     // In eval mode, strip delegation-first instructions so agent implements directly
-    this.effectiveSystemPrompt = config.evalMode
+    const rolePrompt = config.evalMode
       ? AgentRunnerService.stripDelegationInstructions(config.systemPrompt)
       : config.systemPrompt;
+    this.effectiveSystemPrompt = `${rolePrompt}\n\n${AgentRunnerService.HARNESS_RULES}`;
     // Conversation states are lazy-created on first access via the
     // `state` getter, so we don't need to seed `__default__` here.
     // The first message processed will create whichever conversation
@@ -1188,7 +1209,7 @@ export class AgentRunnerService {
     tools: Record<string, unknown>,
     abortSignal: AbortSignal,
   ): Promise<AgentRunResult> {
-    let result = await this.attemptWithErrorRetries(tools, abortSignal);
+    let result = await this.attemptWithSalvage(tools, abortSignal);
     let outcome = classifyFinish(result.finishReason, result.steps, this.config.maxSteps);
     let recoveryAttempts = 0;
@@ -1201,7 +1222,7 @@ export class AgentRunnerService {
       recoveryAttempts++;
       this.streamingCallbacks.onTextChunk?.(`[recover] ${outcome.reason} — continuing (${recoveryAttempts}/${outcome.budget})\n`);
       this.state.messages.push({ role: 'user', content: outcome.nudge });
-      const next = await this.attemptWithErrorRetries(tools, abortSignal);
+      const next = await this.attemptWithSalvage(tools, abortSignal);
       result = mergeRuns(result, next);
       outcome = classifyFinish(next.finishReason, next.steps, this.config.maxSteps);
     }
@@ -1219,6 +1240,161 @@ export class AgentRunnerService {
     };
   }
+  /**
+   * Run one turn, then rescue any tool call the model *wrote* instead of called.
+   *
+   * A weak model sometimes emits its call envelope into the text channel:
+   * the provider returns prose, the SDK sees no tool call, and the step ends
+   * having done nothing — the failure mode behind both the markup users saw
+   * in Slack and the turns that promised work and produced none. Rather than
+   * strip the markup and lose the intent, the envelope is parsed, the tools
+   * are executed for real, and the results are handed back so the turn can
+   * carry on.
+   *
+   * Salvaged calls go through the tool's own `execute`, so approval gates and
+   * command blocklists apply exactly as they do to a native call — this
+   * recovers lost work, it does not widen what the agent may do.
+   *
+   * @param tools - The tool registry for this run
+   * @param abortSignal - Cancels the turn and any further rounds
+   * @returns The turn's result, with salvaged calls folded into `toolCalls`
+   */
+  private async attemptWithSalvage(
+    tools: Record<string, unknown>,
+    abortSignal: AbortSignal,
+  ): Promise<AgentRunResult> {
+    let attempt = await this.attemptWithErrorRetries(tools, abortSignal);
+    const salvaged: ToolCallRecord[] = [];
+    for (let round = 0; round < CREWLY_AGENT_DEFAULTS.MAX_TEXT_TOOL_SALVAGES; round++) {
+      if (abortSignal.aborted) break;
+      const parsed = parseTextToolCalls(attempt.text ?? '');
+      if (parsed.calls.length === 0) break;
+      console.warn('[AgentRunner] Model wrote tool calls as text — executing them:', {
+        round: round + 1,
+        tools: parsed.calls.map(c => c.toolName),
+      });
+      this.streamingCallbacks.onTextChunk?.(
+        `[salvage] running ${parsed.calls.length} tool call(s) the model wrote as text\n`,
+      );
+      const { records, report } = await this.runSalvagedCalls(parsed.calls, tools);
+      salvaged.push(...records);
+      // Rewrite the turn's own message so the transcript does not keep
+      // teaching the model that writing markup is how a tool gets called.
+      this.replaceLastAssistantMessage(parsed.text || '(I wrote a tool call as text instead of calling the tool.)');
+      this.state.messages.push({ role: 'user', content: report });
+      const next = await this.attemptWithErrorRetries(tools, abortSignal);
+      attempt = mergeRuns({ ...attempt, text: parsed.text }, next);
+    }
+    return salvaged.length > 0
+      ? { ...attempt, toolCalls: [...attempt.toolCalls, ...salvaged] }
+      : attempt;
+  }
+  /**
+   * Execute the tool calls recovered from text and describe the results.
+   *
+   * Unknown tools and arguments the schema rejects are reported back rather
+   * than guessed at: the model gets a specific complaint it can act on, which
+   * is far more useful than silence.
+   *
+   * @param calls - Calls parsed out of the model's text
+   * @param tools - The tool registry for this run
+   * @returns Records for the run ledger, and the message to feed back
+   */
+  private async runSalvagedCalls(
+    calls: TextToolCall[],
+    tools: Record<string, unknown>,
+  ): Promise<{ records: ToolCallRecord[]; report: string }> {
+    const records: ToolCallRecord[] = [];
+    const sections: string[] = [];
+    const registry = tools as Record<string, ToolDefinition | undefined>;
+    for (const call of calls.slice(0, CREWLY_AGENT_DEFAULTS.MAX_SALVAGED_CALLS_PER_ROUND)) {
+      // A model that has seen another harness asks for `Bash`, not `bash_exec`.
+      const resolved = resolveToolName(call.toolName, Object.keys(registry));
+      const def = resolved ? registry[resolved] : undefined;
+      if (!resolved || !def || typeof def.execute !== 'function') {
+        sections.push(`### ${call.toolName}\nThere is no tool with that name. Available tools: ${Object.keys(registry).join(', ')}`);
+        continue;
+      }
+      const { args, error } = coerceArgs(call.args, def.inputSchema as unknown as SchemaLike | undefined);
+      if (error) {
+        sections.push(`### ${resolved}\nThe arguments were rejected: ${error}`);
+        continue;
+      }
+      const startedAt = Date.now();
+      this.streamingCallbacks.onToolCallStart?.(resolved, args);
+      let output: unknown;
+      try {
+        output = await def.execute(args);
+      } catch (err) {
+        output = { error: err instanceof Error ? err.message : String(err) };
+      }
+      this.streamingCallbacks.onToolCallFinish?.(resolved, args, output, Date.now() - startedAt);
+      records.push({ toolName: resolved, args, result: output });
+      // Name it as the model wrote it when that differed, so it learns the real name.
+      const heading = resolved === call.toolName ? resolved : `${resolved} (you wrote "${call.toolName}")`;
+      sections.push(`### ${heading}\n${this.summarizeSalvagedResult(output)}`);
+    }
+    const skipped = calls.length - Math.min(calls.length, CREWLY_AGENT_DEFAULTS.MAX_SALVAGED_CALLS_PER_ROUND);
+    const report = [
+      'You wrote your tool calls as text, so the model API never received them. I executed them for you; here is what they returned.',
+      ...sections,
+      skipped > 0 ? `(${skipped} further call(s) were not run — make them yourself.)` : '',
+      'Use the tool-calling mechanism from now on: text in your reply is shown to the user verbatim and executes nothing. Continue the task with these results.',
+    ].filter(Boolean).join('\n\n');
+    return { records, report };
+  }
+  /**
+   * Render a salvaged tool result small enough to feed back.
+   *
+   * @param output - Whatever the tool returned
+   * @returns A string, truncated with a note when it was long
+   */
+  private summarizeSalvagedResult(output: unknown): string {
+    let rendered: string;
+    try {
+      rendered = typeof output === 'string' ? output : JSON.stringify(output, null, 2) ?? String(output);
+    } catch {
+      rendered = String(output);
+    }
+    const limit = CREWLY_AGENT_DEFAULTS.SALVAGED_RESULT_MAX_CHARS;
+    return rendered.length > limit
+      ? `${rendered.slice(0, limit)}\n… (truncated, ${rendered.length - limit} more characters)`
+      : rendered;
+  }
+  /**
+   * Rewrite the assistant message this turn just added to the transcript.
+   *
+   * Stops at the user message that opened the turn, so an earlier, healthy
+   * reply is never touched.
+   *
+   * @param content - Replacement content
+   */
+  private replaceLastAssistantMessage(content: string): void {
+    for (let i = this.state.messages.length - 1; i >= 0; i--) {
+      const message = this.state.messages[i];
+      if (message.role === 'assistant') {
+        this.state.messages[i] = { ...message, content };
+        return;
+      }
+      if (message.role === 'user') return;
+    }
+  }
   /**
    * Run one turn, retrying only on *thrown* failures (rate limits, network,
    * context length). A turn that returns with a bad `finishReason` is the

package/packages/crewly-agent/src/runtime/text-tool-calls.test.ts ADDED Viewed

@@ -0,0 +1,144 @@
+/**
+ * Tests for recovering tool calls a model wrote as text.
+ *
+ * The bug these lock down: deepseek-chat writes its call envelope into the
+ * text channel with its own separators (`<｜｜DSML｜｜ invoke name="Bash">`),
+ * so no tool ever ran and the user was shown the markup instead of an answer
+ * (2026-09-19). Matching is by shape — a new prefix must not defeat it.
+ */
+import { describe, it, expect } from 'vitest';
+import { parseTextToolCalls, hasTextToolCalls, coerceArgs, resolveToolName, type SchemaLike } from './text-tool-calls.js';
+/** The exact bytes deepseek-chat emitted, taken from ~/.crewly/chat.db. */
+const DSML = [
+  'Let me check the repo.',
+  '<｜｜DSML｜｜ calls>',
+  '<｜｜DSML｜｜ invoke name="bash_exec">',
+  '<｜｜DSML｜｜ parameter name="command" string="true">git status --short</｜｜DSML｜｜ parameter>',
+  '<｜｜DSML｜｜ parameter name="timeout" string="true">5000</｜｜DSML｜｜ parameter>',
+  '</｜｜DSML｜｜ invoke>',
+  '</｜｜DSML｜｜ calls>',
+].join('\n');
+/** A minimal Zod-style schema. */
+function schema(check: (v: Record<string, unknown>) => boolean): SchemaLike {
+  return { safeParse: (v: unknown) => (check(v as Record<string, unknown>) ? { success: true, data: v } : { success: false, error: { message: 'bad args' } }) };
+}
+describe('parseTextToolCalls', () => {
+  it('recovers the deepseek envelope, prefix and all, and leaves the prose', () => {
+    const { calls, text } = parseTextToolCalls(DSML);
+    expect(calls).toEqual([
+      { toolName: 'bash_exec', args: { command: 'git status --short', timeout: '5000' } },
+    ]);
+    expect(text).toBe('Let me check the repo.');
+  });
+  it('recovers the plain Claude-style envelope too', () => {
+    const { calls } = parseTextToolCalls('<function_calls><invoke name="read_file"><parameter name="path">a.ts</parameter></invoke></function_calls>');
+    expect(calls).toEqual([{ toolName: 'read_file', args: { path: 'a.ts' } }]);
+  });
+  it('recovers every call in a batch, in order', () => {
+    const { calls } = parseTextToolCalls(
+      '<invoke name="a"><parameter name="x">1</parameter></invoke><invoke name="b"><parameter name="y">2</parameter></invoke>',
+    );
+    expect(calls.map((c) => c.toolName)).toEqual(['a', 'b']);
+    expect(calls[1].args).toEqual({ y: '2' });
+  });
+  it('keeps a multi-line value intact, including its own angle brackets', () => {
+    const { calls } = parseTextToolCalls(
+      '<invoke name="write_file"><parameter name="content">line 1\nif (a < b) { go(); }\nline 3</parameter></invoke>',
+    );
+    expect(calls[0].args.content).toBe('line 1\nif (a < b) { go(); }\nline 3');
+  });
+  it('salvages a call the model never closed', () => {
+    const { calls, text } = parseTextToolCalls('Working.\n<invoke name="bash_exec"><parameter name="command">npm test');
+    expect(calls).toEqual([{ toolName: 'bash_exec', args: { command: 'npm test' } }]);
+    expect(text).toBe('Working.');
+  });
+  it('leaves a fenced example alone — it is documentation, not a call', () => {
+    const raw = 'Here is the syntax:\n\n```\n<invoke name="bash_exec"><parameter name="command">ls</parameter></invoke>\n```';
+    const { calls, text } = parseTextToolCalls(raw);
+    expect(calls).toEqual([]);
+    expect(text).toBe(raw);
+  });
+  it('finds nothing in ordinary prose, and does not touch it', () => {
+    for (const prose of ['', 'The build recalls the cached layer.', 'Use <Parameter> in the docs? no.']) {
+      expect(parseTextToolCalls(prose).calls).toEqual([]);
+    }
+    expect(parseTextToolCalls('The build recalls the cached layer.').text).toBe('The build recalls the cached layer.');
+  });
+  it('ignores an invoke tag with no name rather than inventing one', () => {
+    expect(parseTextToolCalls('<invoke><parameter name="x">1</parameter></invoke>').calls).toEqual([]);
+  });
+});
+describe('hasTextToolCalls', () => {
+  it('is true for any prefix and false for prose', () => {
+    expect(hasTextToolCalls(DSML)).toBe(true);
+    expect(hasTextToolCalls('<invoke name="x">')).toBe(true);
+    expect(hasTextToolCalls('nothing to see')).toBe(false);
+  });
+});
+describe('coerceArgs', () => {
+  it('passes strings through when the schema accepts them', () => {
+    const out = coerceArgs({ command: '5' }, schema((v) => typeof v.command === 'string'));
+    expect(out).toEqual({ args: { command: '5' } });
+  });
+  it('parses JSON-looking values only when the schema refuses the strings', () => {
+    const out = coerceArgs({ timeout: '5000', on: 'true', tags: '["a"]' }, schema((v) => typeof v.timeout === 'number'));
+    expect(out.args).toEqual({ timeout: 5000, on: true, tags: ['a'] });
+    expect(out.error).toBeUndefined();
+  });
+  it('coerces with no schema to give the tool its best shot', () => {
+    expect(coerceArgs({ n: '3', s: 'hello' }).args).toEqual({ n: 3, s: 'hello' });
+  });
+  it('reports the schema complaint instead of calling a tool with bad arguments', () => {
+    const out = coerceArgs({ command: 'ls' }, schema((v) => typeof v.path === 'string'));
+    expect(out.error).toBe('bad args');
+  });
+  it('keeps a value that only looks like JSON', () => {
+    expect(coerceArgs({ command: '{ not json' }).args).toEqual({ command: '{ not json' });
+  });
+});
+describe('resolveToolName', () => {
+  const available = ['bash_exec', 'read_file', 'write_file', 'edit_file', 'glob', 'grep', 'delegate_task', 'git_status'];
+  it('takes an exact name unchanged', () => {
+    expect(resolveToolName('bash_exec', available)).toBe('bash_exec');
+  });
+  it('matches across casing and separators, so GitStatus finds git_status', () => {
+    for (const written of ['GitStatus', 'git-status', 'GIT_STATUS', 'gitStatus']) {
+      expect(resolveToolName(written, available)).toBe('git_status');
+    }
+  });
+  it("resolves the names another harness uses — the live failure was 'Bash'", () => {
+    expect(resolveToolName('Bash', available)).toBe('bash_exec');
+    expect(resolveToolName('Read', available)).toBe('read_file');
+    expect(resolveToolName('Write', available)).toBe('write_file');
+    expect(resolveToolName('Edit', available)).toBe('edit_file');
+    expect(resolveToolName('Task', available)).toBe('delegate_task');
+    expect(resolveToolName('Search', available)).toBe('grep');
+  });
+  it('does not invent a tool the run does not have', () => {
+    expect(resolveToolName('Bash', ['read_file'])).toBeUndefined();
+    expect(resolveToolName('deploy_to_prod', available)).toBeUndefined();
+    expect(resolveToolName('', available)).toBeUndefined();
+  });
+});