lazyclaw 3.99.27 → 4.2.0

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),
+  }));
+}

package/scripts/loop-worker.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+// Detached worker for `lazyclaw loop --detach`.
+//
+// Invoked by the parent CLI with the same provider/model the parent
+// resolved, plus a loop id pointing at the state directory the parent
+// pre-created. Streams nothing to stdout — we are headless. Every
+// iteration's outcome lands in iterations.log, and the final disposition
+// lands in result.json + meta.status. SIGTERM flips status to `killed`
+// and unwinds cleanly so a follow-up SIGKILL is rarely needed.
+//
+// Argv contract (all required except --until / --session-existing):
+//   --loop-id <id>
+//   --prompt <text>
+//   --max <N>
+//   --provider <name>
+//   --until <regex>
+//   --session-existing <id>      reuse the named chat session
+//   --cfg-dir <path>             override LAZYCLAW_CONFIG_DIR
+//   --model <name>               provider-specific model name
+//
+// LC_FAIL_AT_ITER=<N> is honored as a test hook: exits with code 7 just
+// before iteration N's provider call. Used by phase 2 spec to assert
+// the `failed` meta status path.
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(HERE, '..');
+
+function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const t = argv[i];
+    if (t.startsWith('--')) {
+      const key = t.slice(2);
+      const v = argv[i + 1];
+      if (v === undefined || v.startsWith('--')) {
+        out[key] = true;
+      } else {
+        out[key] = v;
+        i++;
+      }
+    } else {
+      out._.push(t);
+    }
+  }
+  return out;
+}
+
+const args = parseArgs(process.argv.slice(2));
+const loopId = args['loop-id'];
+if (!loopId) {
+  process.stderr.write('loop-worker: --loop-id required\n');
+  process.exit(2);
+}
+
+if (args['cfg-dir']) {
+  process.env.LAZYCLAW_CONFIG_DIR = args['cfg-dir'];
+}
+
+const loops = await import(path.join(REPO_ROOT, 'loops.mjs'));
+const sessions = await import(path.join(REPO_ROOT, 'sessions.mjs'));
+const loopEngine = await import(path.join(REPO_ROOT, 'loop-engine.mjs'));
+const registryUrl = path.join(REPO_ROOT, 'providers', 'registry.mjs');
+const { PROVIDERS } = await import(registryUrl);
+
+const cfgDir = process.env.LAZYCLAW_CONFIG_DIR || loops.defaultConfigDir();
+const sessionId = args['session-existing'] || `loop:${loopId}`;
+
+const provName = args.provider || 'mock';
+const prov = PROVIDERS[provName];
+if (!prov) {
+  loops.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
+  loops.writeResult(loopId, { error: `unknown provider: ${provName}` }, cfgDir);
+  process.exit(2);
+}
+
+const until = args.until ? loopEngine.compileUntil(args.until) : null;
+const max = Number(args.max) || loopEngine.LOOP_MAX_DEFAULT;
+
+// Initial meta — pid was filled by parent. We update startedAt here so
+// the timestamp reflects when the worker actually started executing, not
+// when the parent forked us.
+loops.patchMeta(loopId, { status: 'running', startedAt: new Date().toISOString() }, cfgDir);
+
+const ac = new AbortController();
+function onTerm(sig) {
+  ac.abort();
+  loops.patchMeta(loopId, { status: 'killed', finishedAt: new Date().toISOString(), signal: sig }, cfgDir);
+  loops.writeResult(loopId, { stoppedBy: 'kill', signal: sig }, cfgDir);
+  // Give the in-flight stream a moment to unwind before we exit.
+  setTimeout(() => process.exit(143), 50);
+}
+process.on('SIGTERM', () => onTerm('SIGTERM'));
+process.on('SIGINT', () => onTerm('SIGINT'));
+
+const failAtIter = Number(process.env.LC_FAIL_AT_ITER) || 0;
+let iterCounter = 0;
+
+async function sendOnce(messages, signal) {
+  iterCounter++;
+  if (failAtIter && iterCounter === failAtIter) {
+    process.exit(7);
+  }
+  let acc = '';
+  for await (const chunk of prov.sendMessage(messages, {
+    apiKey: process.env.LAZYCLAW_API_KEY || '',
+    model: args.model,
+    signal,
+  })) {
+    acc += chunk;
+  }
+  return acc;
+}
+
+const messages = [];
+// Hydrate prior turns if reusing an existing session — the engine appends
+// every successful pair, so resume semantics line up with `/loop` in REPL.
+if (sessionId && sessions.sessionPath) {
+  try {
+    const prior = sessions.loadTurns(sessionId, cfgDir);
+    for (const t of prior) messages.push({ role: t.role, content: t.content });
+  } catch { /* fresh session */ }
+}
+
+const persist = (role, content) => {
+  try { sessions.appendTurn(sessionId, role, content, cfgDir); }
+  catch { /* surface via result.json on failure */ }
+};
+
+const onIteration = ({ i, max: m, reply }) => {
+  loops.appendIteration(loopId, {
+    iteration: i,
+    of: m,
+    bytes: reply.length,
+    preview: reply.slice(0, 200),
+  }, cfgDir);
+};
+
+try {
+  const result = await loopEngine.runLoop({
+    prompt: args.prompt || '',
+    max,
+    until,
+    messages,
+    sendOnce,
+    persist,
+    onIteration,
+    signal: ac.signal,
+  });
+  const finalStatus = result.stoppedBy === 'abort' ? 'killed' : 'completed';
+  loops.patchMeta(loopId, { status: finalStatus, finishedAt: new Date().toISOString() }, cfgDir);
+  loops.writeResult(loopId, result, cfgDir);
+  process.exit(0);
+} catch (err) {
+  loops.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
+  loops.writeResult(loopId, { error: err?.message || String(err), stack: err?.stack }, cfgDir);
+  process.exit(1);
+}

package/sessions.mjs

@@ -17,6 +17,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { appendRecent as _memoryAppendRecent } from './memory.mjs';
 
 const SESSIONS_DIRNAME = 'sessions';
 
@@ -74,6 +75,10 @@ export function appendTurn(id, role, content, configDir = defaultConfigDir()) {
   fs.mkdirSync(path.dirname(p), { recursive: true });
   const line = JSON.stringify({ role, content: String(content ?? ''), ts: Date.now() }) + '\n';
   fs.appendFileSync(p, line);
+  // Write-through to the memory recency log. Best-effort; failures
+  // never propagate up — a missing or broken memory store must not
+  // break the session-write path.
+  _memoryAppendRecent(id, role, content, configDir);
 }
 
 export function clearSession(id, configDir = defaultConfigDir()) {