rewritable 0.1.0 → 0.5.0

package/src/agent-loop.mjs

@@ -0,0 +1,155 @@
+// Multi-turn tool-use agent loop against an OpenAI-compatible
+// /chat/completions endpoint. Mirrors the browser runtime's modify() shape in
+// seeds/rewritable.html: a retry budget of 3, single tool_call per turn,
+// corrective user message on no_tool_call, tool_result on invalid_json.
+//
+// Backend HTTP errors are terminal (not retried) for v1 — same posture as the
+// runtime, which surfaces network failures directly to the user.
+//
+// Parallel tool_calls are not supported: the loop takes tool_calls[0] and
+// ignores the rest. The seed's modify() loop is also single-call-per-turn, so
+// this matches existing behavior. Multi-call dispatching is a v2 concern.
+//
+// Note: fetch has no timeout. Callers (Task 7's CLI process or the bridge
+// transport) are responsible for any timeout/cancellation.
+
+const RETRY_BUDGET = 3;
+
+export class AgentError extends Error {
+  constructor(subcode, details = {}) {
+    super(subcode);
+    this.subcode = subcode;
+    this.details = details;
+  }
+}
+
+/**
+ * Run a multi-turn tool-use loop. Returns the first valid envelope produced
+ * by the model.
+ *
+ * @param {object}   opts
+ * @param {string}   opts.systemPrompt - System role content.
+ * @param {Array}    opts.toolSchemas  - Tool definitions (OpenAI-compatible).
+ * @param {string}   opts.currentDoc   - Document content for the user message.
+ * @param {string}   opts.instruction  - User instruction for the user message.
+ * @param {string[]} [opts.frozenZoneNames] - Frozen zone names visible to the
+ *   model. Defaults to `[]`. Surfaces in the user prompt so the model
+ *   knows which marker-form zones to preserve verbatim.
+ * @param {{baseUrl: string, model: string, apiKey?: string}} opts.backend
+ * @param {(info: {attempt: number, reason: string, toolName?: string}) => void} [opts.onRetry]
+ *   Optional callback fired each time a retry is queued. `attempt` is the
+ *   attempt that just failed (1-indexed).
+ * @returns {Promise<{envelope: object, toolName: string, messages: Array}>}
+ * @throws {AgentError} subcode: 'no_envelope_after_retries' | 'backend_error'
+ */
+export async function runAgentLoop({
+  systemPrompt,
+  toolSchemas,
+  currentDoc,
+  instruction,
+  frozenZoneNames = [],
+  backend,
+  onRetry,
+}) {
+  // Seed parity (seeds/rewritable.html buildUserPrompt): the user message
+  // names the request, lists frozen-zone names so the model knows what to
+  // preserve, and fences the doc in <DOC>…</DOC> so the model can't confuse
+  // doc bytes with instruction bytes. The CLI surface is a strict subset of
+  // the seed's prompt — lock ranges and the long explanatory parenthetical
+  // are seed-only.
+  const fzText = frozenZoneNames.length === 0 ? '(none)' : frozenZoneNames.join(', ');
+  const userContent =
+    'User request:\n' + instruction +
+    '\n\nFrozen zones in the current doc: ' + fzText +
+    '\n\n<DOC>\n' + currentDoc + '\n</DOC>';
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    { role: 'user',   content: userContent },
+  ];
+
+  for (let attempt = 1; attempt <= RETRY_BUDGET; attempt++) {
+    let response;
+    try {
+      response = await callBackend(backend, { messages, tools: toolSchemas });
+    } catch (e) {
+      // Network or HTTP error — terminal for v1.
+      throw new AgentError('backend_error', { attempt, message: e.message });
+    }
+
+    const message = response?.choices?.[0]?.message;
+    if (!message) {
+      throw new AgentError('backend_error', {
+        attempt,
+        message: 'malformed response: no message in choices[0]',
+      });
+    }
+
+    if (!message.tool_calls || message.tool_calls.length === 0) {
+      messages.push(message);
+      if (onRetry) onRetry({ attempt, reason: 'no_tool_call', toolName: undefined });
+      messages.push({
+        role: 'user',
+        content: 'Retry: you must call one of the provided tools (no plain text). Try again.',
+      });
+      continue;
+    }
+
+    // v1: take the first tool_call, ignore any others.
+    const call = message.tool_calls[0];
+    let envelope;
+    try {
+      envelope = JSON.parse(call.function.arguments);
+    } catch (e) {
+      if (onRetry) onRetry({ attempt, reason: 'invalid_json', toolName: call.function.name });
+      // Before echoing the assistant message, trim tool_calls to only the one we're responding to.
+      // Required by OpenAI-compatible providers: every tool_use id in the assistant message must
+      // have a matching tool_result on the next turn. Echoing unconsumed parallel tool_calls
+      // causes 400s on Anthropic-backed providers. Matches seeds/rewritable.html:3262.
+      const echoMessage = message.tool_calls.length > 1
+        ? { ...message, tool_calls: [call] }
+        : message;
+      messages.push(echoMessage);
+      messages.push({
+        role: 'tool',
+        tool_call_id: call.id,
+        content: JSON.stringify({
+          ok: false,
+          code: 'malformed_envelope',
+          message: `invalid JSON in tool arguments: ${e.message}`,
+        }),
+      });
+      continue;
+    }
+
+    messages.push(message);
+    return { envelope, toolName: call.function.name, messages };
+  }
+
+  throw new AgentError('no_envelope_after_retries', { retries: RETRY_BUDGET });
+}
+
+async function callBackend({ baseUrl, model, apiKey }, body) {
+  const headers = { 'Content-Type': 'application/json' };
+  if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
+  const url = baseUrl.replace(/\/+$/, '') + '/chat/completions';
+  // Seed parity (seeds/rewritable.html openAiCompatChat caller in modify()):
+  // every request carries max_tokens: 32000 and tool_choice: 'auto'. The
+  // tool_choice default forces the model to call one of the provided tools
+  // rather than emitting plain text (which would trip our no_tool_call retry).
+  const res = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      model,
+      max_tokens: 32000,
+      tool_choice: 'auto',
+      ...body,
+    }),
+  });
+  if (!res.ok) {
+    let text = '';
+    try { text = await res.text(); } catch {}
+    throw new Error(`backend returned ${res.status}: ${text.slice(0, 200)}`);
+  }
+  return res.json();
+}