lazyclaw 3.99.28 → 4.2.1

package/providers/tool_use/claude_cli.mjs

@@ -0,0 +1,215 @@
+// claude-cli tool-use adapter (Phase 19).
+//
+// Unlike the API-based adapters, this one wraps the official `claude`
+// CLI (Claude Code). The CLI runs the *entire* tool-use loop inside
+// itself — bash, edit, read, write, grep, etc. — and emits a single
+// final text answer. From lazyclaw's mention-router perspective every
+// call resolves to `{ kind: 'final', text }` after one iteration, so
+// the multi-agent handoff still works (we just lose lazyclaw's audit
+// log for tools claude ran on its own; the CLI keeps its own log).
+//
+// Wiring choices:
+//   - --output-format stream-json + --verbose so we can accumulate
+//     text deltas exactly like providers/claude_cli.mjs does (proven
+//     parser, no second JSON shape to maintain).
+//   - --permission-mode bypassPermissions because spec §10 #6 ships
+//     destructive-pattern confirmation OFF by default. Audit log
+//     still captures every tool the CLI runs (via the CLI's own
+//     telemetry — we don't double-write here).
+//   - --tools maps the lazyclaw whitelist into claude's built-in
+//     names (bash → Bash, etc.). When the whitelist is empty we pass
+//     `""` so tools are fully disabled.
+//   - --system-prompt carries the agent role + memory + team metadata
+//     the mention router builds.
+//   - LAZYCLAW_CLAUDE_BIN overrides the binary path so tests can
+//     point at a deterministic shim script.
+
+import { spawn } from 'node:child_process';
+
+const DEFAULT_BIN = 'claude';
+const LAZYCLAW_TO_CLAUDE_TOOL = {
+  bash: 'Bash',
+  read: 'Read',
+  write: 'Write',
+  grep: 'Grep',
+  web_search: 'WebSearch',
+  web_fetch: 'WebFetch',
+};
+
+export class ClaudeCliToolUseError extends Error {
+  constructor(message, code, body) {
+    super(message);
+    this.name = 'ClaudeCliToolUseError';
+    this.code = code || 'CLAUDE_CLI_ERR';
+    if (body) this.body = body;
+  }
+}
+
+// The schemas value from listToolSchemas comes in lazyclaw form; claude
+// expects a comma-separated string of its OWN built-in tool names.
+// Returning a string rather than an array lets us pass it as a single
+// CLI argument unchanged. An empty string is meaningful — it disables
+// all tools — so callers should distinguish "no tools whitelisted" from
+// "tools field omitted".
+export function toClaudeTools(schemas) {
+  if (!Array.isArray(schemas) || schemas.length === 0) return '';
+  const names = schemas
+    .map((s) => LAZYCLAW_TO_CLAUDE_TOOL[s?.name])
+    .filter(Boolean);
+  return [...new Set(names)].join(',');
+}
+
+export function normalizeHistory(turns) {
+  return Array.isArray(turns) ? [...turns] : [];
+}
+
+export function initialUserMessage(text) {
+  return { role: 'user', content: String(text) };
+}
+
+// Build the single prompt string the CLI sees. Concatenate every
+// non-system message, prefixing prior assistant turns with a "[prior]
+// " marker so the model can tell them apart from the live user turn.
+// Mirrors the established pattern in providers/claude_cli.mjs.
+function buildPrompt(messages) {
+  const lastUser = [...messages].reverse().find((m) => m && m.role === 'user');
+  if (!lastUser) return '';
+  const history = messages
+    .filter((m) => m !== lastUser && m && m.role !== 'system')
+    .map((m) => {
+      const tag = m.role === 'assistant' ? '[prior assistant]' : '[prior user]';
+      return `${tag} ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`;
+    })
+    .join('\n\n');
+  return history ? `${history}\n\n${lastUser.content}` : String(lastUser.content);
+}
+
+function extractTextDelta(obj) {
+  if (!obj || typeof obj !== 'object') return '';
+  if (obj.type !== 'stream_event') return '';
+  const ev = obj.event || {};
+  if (ev.type === 'content_block_delta') {
+    const d = ev.delta || {};
+    if (d.type === 'text_delta' && typeof d.text === 'string') return d.text;
+  }
+  return '';
+}
+
+// Walk stream-json output to completion, accumulating text deltas, and
+// return the final concatenated reply. The CLI also emits an
+// 'assistant' record carrying the full message content; we fall back
+// to that when no `stream_event` deltas were observed (some claude
+// versions only emit the consolidated record).
+async function readUntilDone(proc) {
+  return new Promise((resolve, reject) => {
+    let stdout = '';
+    let stderr = '';
+    let acc = '';
+    let assistantFallback = '';
+    let resultText = '';
+    proc.stdout.setEncoding('utf8');
+    proc.stderr.setEncoding('utf8');
+    proc.stdout.on('data', (chunk) => {
+      stdout += chunk;
+      let nl;
+      while ((nl = stdout.indexOf('\n')) >= 0) {
+        const line = stdout.slice(0, nl).trim();
+        stdout = stdout.slice(nl + 1);
+        if (!line) continue;
+        let obj;
+        try { obj = JSON.parse(line); } catch { continue; }
+        const delta = extractTextDelta(obj);
+        if (delta) acc += delta;
+        // Fallback: consolidated assistant content block (no streaming).
+        if (obj?.type === 'assistant' && obj?.message?.content) {
+          for (const block of obj.message.content) {
+            if (block?.type === 'text' && typeof block.text === 'string') {
+              assistantFallback += block.text;
+            }
+          }
+        }
+        if (obj?.type === 'result' && typeof obj.result === 'string') {
+          resultText = obj.result;
+        }
+      }
+    });
+    proc.stderr.on('data', (chunk) => { stderr += chunk; });
+    proc.on('error', reject);
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        return reject(new ClaudeCliToolUseError(`claude CLI exit ${code}: ${stderr.slice(0, 300)}`, 'CLAUDE_CLI_EXIT', stderr));
+      }
+      // Prefer accumulated stream deltas; fall back to the assistant
+      // record or the final result text when streaming was disabled.
+      const text = acc || assistantFallback || resultText || '';
+      resolve(text);
+    });
+  });
+}
+
+export async function callOnce({
+  messages,
+  tools = [],
+  model,
+  apiKey,           // unused — the CLI authenticates itself
+  system,
+  baseUrl,          // unused
+  fetchImpl,        // unused
+  signal,
+  bin,
+  cwd,
+  permissionMode = 'bypassPermissions',
+} = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new ClaudeCliToolUseError('messages[] is required and non-empty', 'NO_MESSAGES');
+  }
+  const prompt = buildPrompt(messages);
+  if (!prompt) {
+    throw new ClaudeCliToolUseError('messages produced an empty prompt', 'NO_PROMPT');
+  }
+  const args = [
+    '-p', prompt,
+    '--output-format', 'stream-json',
+    '--include-partial-messages',
+    '--verbose',
+    '--permission-mode', permissionMode,
+  ];
+  if (model) args.push('--model', model);
+  if (system && String(system).trim()) {
+    args.push('--system-prompt', String(system));
+  }
+  // Phase 19: pass the lazyclaw whitelist through to claude's --tools
+  // even when empty (an empty string explicitly disables every tool).
+  const toolsArg = toClaudeTools(tools);
+  args.push('--tools', toolsArg);
+
+  const binPath = bin || process.env.LAZYCLAW_CLAUDE_BIN || DEFAULT_BIN;
+  let proc;
+  try {
+    proc = spawn(binPath, args, {
+      cwd: cwd || process.cwd(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+  } catch (err) {
+    if (err?.code === 'ENOENT') {
+      throw new ClaudeCliToolUseError(`claude CLI binary not found at "${binPath}"`, 'CLAUDE_CLI_NOT_FOUND');
+    }
+    throw err;
+  }
+  const onAbort = () => { try { proc.kill('SIGTERM'); } catch { /* gone */ } };
+  if (signal) signal.addEventListener('abort', onAbort);
+  try {
+    const text = await readUntilDone(proc);
+    return { kind: 'final', text, raw: null };
+  } finally {
+    if (signal) signal.removeEventListener('abort', onAbort);
+  }
+}
+
+// The CLI handles tools internally — these helpers exist to keep the
+// adapter surface symmetrical with anthropic/openai/gemini. Neither
+// path is actually exercised at runtime because callOnce always
+// returns kind:'final'.
+export function assistantTurnMessages(_resp) { return []; }
+export function toolResultMessages(_results) { return []; }

package/providers/tool_use/gemini.mjs

@@ -0,0 +1,189 @@
+// Gemini tool-use adapter.
+//
+// Calls POST /v1beta/models/{model}:generateContent non-streaming and
+// normalises the response into the agent_turn envelope shape:
+//   { kind: 'final',      text }
+//   { kind: 'tool_calls', text?, calls, assistantContent }
+//
+// Wire-level peculiarities this module hides:
+//   - role names are "user" and "model" (not "assistant")
+//   - message body is `parts: [{text}, {functionCall}, ...]`
+//   - functionCall.args is a native JSON object (no string parsing)
+//   - functionResponse goes back in a role:user message inside its own
+//     `parts` block; correlation is by `name`, not an id
+//   - system prompt rides on `system_instruction.parts[0].text`
+//   - tools are declared inside ONE `tools[0].function_declarations` list
+//   - some JSON-Schema keys (`additionalProperties`, `$schema`,
+//     `examples`) are rejected by Gemini; we strip them before sending
+//
+// Docs: https://ai.google.dev/api/rest/v1beta/models/generateContent
+
+const DEFAULT_BASE = 'https://generativelanguage.googleapis.com/v1beta';
+
+export class GeminiToolUseError extends Error {
+  constructor(message, code, body) {
+    super(message);
+    this.name = 'GeminiToolUseError';
+    this.code = code || 'GEMINI_ERR';
+    if (body) this.body = body;
+  }
+}
+
+// Gemini's function_declarations.parameters schema is a strict subset of
+// JSON Schema. Strip the keys it rejects so a registry-shared schema can
+// be reused across providers without forcing the runner to know about
+// per-provider quirks.
+function sanitizeGeminiSchema(schema) {
+  if (!schema || typeof schema !== 'object') return schema;
+  if (Array.isArray(schema)) return schema.map(sanitizeGeminiSchema);
+  const { additionalProperties, $schema, examples, ...rest } = schema;
+  const out = {};
+  for (const [k, v] of Object.entries(rest)) {
+    out[k] = sanitizeGeminiSchema(v);
+  }
+  return out;
+}
+
+export function toGeminiTools(schemas) {
+  if (!schemas || schemas.length === 0) return [];
+  const declarations = schemas.map((s) => ({
+    name: s.name,
+    description: s.description,
+    parameters: sanitizeGeminiSchema(s.parameters),
+  }));
+  return [{ function_declarations: declarations }];
+}
+
+// agent_turn passes history as plain [{role:'user'|'assistant', content:'text'}].
+// Convert each entry into Gemini's parts shape. Anything that looks like
+// an already-Gemini message (has `parts`) is passed through unchanged so
+// callers can pre-build native turns when they need to.
+export function normalizeHistory(turns) {
+  if (!Array.isArray(turns)) return [];
+  return turns.map((t) => {
+    if (t && typeof t === 'object' && Array.isArray(t.parts)) return t;
+    const role = t?.role === 'assistant' ? 'model' : (t?.role || 'user');
+    const text = typeof t?.content === 'string' ? t.content : '';
+    return { role, parts: [{ text }] };
+  });
+}
+
+export function initialUserMessage(text) {
+  return { role: 'user', parts: [{ text: String(text) }] };
+}
+
+export async function callOnce({
+  messages,
+  tools = [],
+  model,
+  apiKey,
+  system,
+  baseUrl,
+  fetchImpl,
+  signal,
+} = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new GeminiToolUseError('messages[] is required and non-empty', 'NO_MESSAGES');
+  }
+  if (!apiKey) {
+    throw new GeminiToolUseError('apiKey is required', 'NO_API_KEY');
+  }
+  const m = model || 'gemini-2.5-flash';
+  const url = `${(baseUrl || DEFAULT_BASE).replace(/\/$/, '')}/models/${encodeURIComponent(m)}:generateContent`;
+  const fetchFn = fetchImpl || globalThis.fetch;
+
+  const body = { contents: messages };
+  if (tools && tools.length) body.tools = tools;
+  if (system && String(system).trim()) {
+    body.system_instruction = { parts: [{ text: String(system) }] };
+  }
+
+  const res = await fetchFn(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-goog-api-key': apiKey,
+    },
+    body: JSON.stringify(body),
+    signal,
+  });
+  if (!res.ok) {
+    let raw = '';
+    try { raw = await res.text(); } catch { /* ignore */ }
+    throw new GeminiToolUseError(`HTTP ${res.status}: ${raw.slice(0, 300)}`, 'HTTP_FAIL', raw);
+  }
+  const json = await res.json();
+  return parseResponse(json);
+}
+
+export function parseResponse(json) {
+  const candidate = json?.candidates?.[0];
+  const parts = candidate?.content?.parts || [];
+  const textParts = [];
+  const calls = [];
+  for (const p of parts) {
+    if (!p || typeof p !== 'object') continue;
+    if (typeof p.text === 'string') textParts.push(p.text);
+    else if (p.functionCall && p.functionCall.name) {
+      // Gemini has no `id` field; we synthesise a stable one from the
+      // call index + name so multi-call turns can still be correlated
+      // by the runner. We strip the id again before sending the
+      // functionResponse back (Gemini matches by name).
+      calls.push({
+        id: `gem_${calls.length}_${p.functionCall.name}`,
+        name: p.functionCall.name,
+        input: p.functionCall.args || {},
+      });
+    }
+  }
+  const text = textParts.join('');
+  if (calls.length === 0) {
+    return { kind: 'final', text, raw: json };
+  }
+  // assistantContent is the entire model turn so the runner can echo it
+  // back into `contents` for the next request.
+  return {
+    kind: 'tool_calls',
+    text,
+    calls,
+    assistantContent: candidate?.content || { role: 'model', parts },
+    raw: json,
+  };
+}
+
+export function assistantTurnMessages(resp) {
+  // Echo the model turn straight back so the next request includes the
+  // functionCall parts the API expects to see paired with responses.
+  return [resp.assistantContent];
+}
+
+export function toolResultMessages(results) {
+  // All tool responses fit into a SINGLE user-role message whose parts
+  // are functionResponse entries. Gemini matches by name, so we drop
+  // the synthetic id.
+  const parts = (results || []).map((r) => ({
+    functionResponse: {
+      name: nameFromSyntheticId(r.id),
+      response: normaliseToolResponse(r.content, r.isError),
+    },
+  }));
+  return [{ role: 'user', parts }];
+}
+
+function nameFromSyntheticId(id) {
+  if (typeof id !== 'string') return String(id || 'unknown');
+  // synthetic shape: `gem_<idx>_<name>`. Strip the prefix.
+  const m = /^gem_\d+_(.+)$/.exec(id);
+  return m ? m[1] : id;
+}
+
+function normaliseToolResponse(content, isError) {
+  // Gemini wants an object, not a free-form string. Wrap primitives.
+  let body;
+  if (content === null || content === undefined) body = {};
+  else if (typeof content === 'string') body = { content };
+  else if (typeof content === 'object') body = content;
+  else body = { content: String(content) };
+  if (isError) return { ...body, is_error: true };
+  return body;
+}

package/providers/tool_use/openai.mjs

@@ -0,0 +1,140 @@
+// OpenAI tool-use adapter.
+//
+// Calls POST /v1/chat/completions non-streaming and normalises the
+// response into the same envelope shape Anthropic's adapter uses:
+//   { kind: 'final',      text }
+//   { kind: 'tool_calls', text?, calls, assistantContent }
+//
+// Wire-level differences vs Anthropic that this module hides:
+//   - `function.arguments` is a JSON STRING; we parse it.
+//   - `content` on the assistant message can be null when tool_calls is
+//     present; downstream code receives `text: ''` in that case.
+//   - Each tool result becomes its own message with role='tool' and the
+//     `tool_call_id` field — so `toolResultMessages()` returns N
+//     entries (vs Anthropic's single user-message wrapper).
+//
+// Docs: https://platform.openai.com/docs/guides/function-calling
+
+const DEFAULT_BASE = 'https://api.openai.com/v1';
+const DEFAULT_MAX_TOKENS = 4096;
+
+export class OpenAIToolUseError extends Error {
+  constructor(message, code, body) {
+    super(message);
+    this.name = 'OpenAIToolUseError';
+    this.code = code || 'OPENAI_ERR';
+    if (body) this.body = body;
+  }
+}
+
+export function toOpenAITools(schemas) {
+  return (schemas || []).map((s) => ({
+    type: 'function',
+    function: {
+      name: s.name,
+      description: s.description,
+      parameters: s.parameters,
+    },
+  }));
+}
+
+export async function callOnce({
+  messages,
+  tools = [],
+  model,
+  apiKey,
+  system,
+  maxTokens = DEFAULT_MAX_TOKENS,
+  baseUrl,
+  fetchImpl,
+  signal,
+} = {}) {
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new OpenAIToolUseError('messages[] is required and non-empty', 'NO_MESSAGES');
+  }
+  if (!apiKey) {
+    throw new OpenAIToolUseError('apiKey is required', 'NO_API_KEY');
+  }
+  const url = `${(baseUrl || DEFAULT_BASE).replace(/\/$/, '')}/chat/completions`;
+  const fetchFn = fetchImpl || globalThis.fetch;
+
+  // OpenAI carries the system prompt as the first message rather than a
+  // separate field. We only prepend when the caller has NOT already
+  // injected one (history replays may include the system turn).
+  const fullMessages = [];
+  const hasSystem = messages.some((m) => m?.role === 'system');
+  if (!hasSystem && system && String(system).trim()) {
+    fullMessages.push({ role: 'system', content: String(system) });
+  }
+  fullMessages.push(...messages);
+
+  const body = {
+    model: model || 'gpt-4.1',
+    messages: fullMessages,
+    max_tokens: maxTokens,
+  };
+  if (tools && tools.length) body.tools = tools;
+
+  const res = await fetchFn(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+    signal,
+  });
+  if (!res.ok) {
+    let raw = '';
+    try { raw = await res.text(); } catch { /* ignore */ }
+    throw new OpenAIToolUseError(`HTTP ${res.status}: ${raw.slice(0, 300)}`, 'HTTP_FAIL', raw);
+  }
+  const json = await res.json();
+  return parseResponse(json);
+}
+
+export function parseResponse(json) {
+  const choice = Array.isArray(json?.choices) ? json.choices[0] : null;
+  const msg = choice?.message || {};
+  const rawToolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+  const text = typeof msg.content === 'string' ? msg.content : '';
+  if (rawToolCalls.length === 0) {
+    return { kind: 'final', text, raw: json };
+  }
+  const calls = rawToolCalls.map((tc) => {
+    let input = {};
+    const a = tc?.function?.arguments;
+    if (typeof a === 'string') {
+      try { input = JSON.parse(a); } catch { input = {}; }
+    } else if (a && typeof a === 'object') {
+      input = a;
+    }
+    return { id: tc.id, name: tc?.function?.name, input };
+  });
+  return { kind: 'tool_calls', text, calls, assistantContent: msg, raw: json };
+}
+
+// OpenAI accepts the agent_turn-native {role, content} shape directly.
+export function normalizeHistory(turns) {
+  return Array.isArray(turns) ? [...turns] : [];
+}
+
+export function initialUserMessage(text) {
+  return { role: 'user', content: String(text) };
+}
+
+// Echo the assistant turn so the next request preserves the model's
+// reasoning and tool_calls ids for correlation. OpenAI already gives us
+// a full message object; we just wrap it.
+export function assistantTurnMessages(resp) {
+  return [resp.assistantContent];
+}
+
+// Each tool result becomes its own role:tool message.
+export function toolResultMessages(results) {
+  return (results || []).map((r) => ({
+    role: 'tool',
+    tool_call_id: r.id,
+    content: typeof r.content === 'string' ? r.content : JSON.stringify(r.content),
+  }));
+}