jeo-code 0.5.12 → 0.5.14

package/src/ai/providers/openai-responses.ts

@@ -14,6 +14,7 @@ import type { Credential } from "../../auth";
 import type { CallOptions, Message } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
+import { serializeToolCalls } from "../../agent/tool-schemas";
 
 export const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
 
@@ -63,6 +64,11 @@ export function codexResponsesRequest(
     stream: true, // the Codex backend only streams
     store: false,
   };
+  if (options.tools?.length) {
+    // Responses API function tools (flat shape). tool_choice "auto" keeps prose + `done`.
+    payload.tools = options.tools.map(t => ({ type: "function", name: t.name, description: t.description, parameters: t.parameters, strict: false }));
+    payload.tool_choice = "auto";
+  }
   // Map thinkingLevel → reasoning effort for Codex reasoning models (gjc parity).
   // Drop out-of-enum values instead of forwarding them — the backend 400s on unknown efforts.
   if (options.reasoningEffort && VALID_REASONING_EFFORTS.has(options.reasoningEffort)) {
@@ -87,6 +93,10 @@ export interface ResponsesEvent {
   /** `response.incomplete` cause (e.g. max_output_tokens) — surfaced when the
    *  whole response produced no text (round-5 #1). */
   incompleteReason?: string;
+  /** NATIVE function_call output items (accumulated by the caller across SSE events). */
+  toolCallName?: string;
+  toolCallArgsDelta?: string;
+  toolCallIndex?: number;
 }
 
 /** Parse one Responses SSE `data:` payload into a delta / usage / error. */
@@ -94,6 +104,8 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
   let o: {
     type?: string;
     delta?: unknown;
+    item?: { type?: string; name?: string };
+    output_index?: number;
     response?: {
       usage?: { input_tokens?: number; output_tokens?: number };
       error?: { message?: string };
@@ -106,6 +118,12 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
   } catch {
     return {};
   }
+  if (o.type === "response.output_item.added" && o.item?.type === "function_call") {
+    return { toolCallName: o.item.name, toolCallIndex: o.output_index };
+  }
+  if (o.type === "response.function_call_arguments.delta" && typeof o.delta === "string") {
+    return { toolCallArgsDelta: o.delta, toolCallIndex: o.output_index };
+  }
   if (o.type === "response.output_text.delta" && typeof o.delta === "string") return { delta: o.delta };
   // `response.incomplete` (max_output_tokens / content filter) also carries usage — don't drop it.
   if ((o.type === "response.completed" || o.type === "response.incomplete") && o.response?.usage) {
@@ -120,6 +138,33 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
   return {};
 }
 
+/** Accumulate Responses function_call name + streamed argument fragments by output index. */
+function accumulateResponsesToolCall(acc: Map<number, { name: string; args: string }>, ev: ResponsesEvent): void {
+  if (ev.toolCallName !== undefined) {
+    const i = ev.toolCallIndex ?? 0;
+    const b = acc.get(i) ?? { name: "", args: "" };
+    b.name = ev.toolCallName;
+    acc.set(i, b);
+  }
+  if (ev.toolCallArgsDelta) {
+    const i = ev.toolCallIndex ?? 0;
+    const b = acc.get(i) ?? { name: "", args: "" };
+    b.args += ev.toolCallArgsDelta;
+    acc.set(i, b);
+  }
+}
+
+/** Re-serialize accumulated Responses function calls into the engine's canonical JSON. */
+function serializeResponsesToolCalls(acc: Map<number, { name: string; args: string }>): string | null {
+  if (acc.size === 0) return null;
+  const calls = [...acc.values()].map(b => {
+    let args: Record<string, unknown> = {};
+    try { args = b.args ? JSON.parse(b.args) : {}; } catch { args = {}; }
+    return { tool: b.name, arguments: args };
+  });
+  return serializeToolCalls(calls);
+}
+
 /** Round-5 #1: no-text completions surface their cause instead of returning "". */
 function emptyCompletionError(reason: string | undefined): Error {
   const hint = reason === "max_output_tokens"
@@ -136,13 +181,18 @@ export async function codexResponsesCall(messages: Message[], options: CallOptio
   if (!response.body) return "";
   let out = "";
   let incompleteReason: string | undefined;
+  const toolAcc = new Map<number, { name: string; args: string }>();
   for await (const data of readSse(response.body)) {
     const ev = parseResponsesEvent(data);
     if (ev.delta) out += ev.delta;
+    accumulateResponsesToolCall(toolAcc, ev);
     if (ev.usage) options.onUsage?.(ev.usage);
     if (ev.incompleteReason) incompleteReason = ev.incompleteReason;
     if (ev.error) throw new Error(`OpenAI Codex response failed: ${ev.error}`);
   }
+  // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
+  const envelope = serializeResponsesToolCalls(toolAcc);
+  if (envelope) return envelope;
   if (!out) throw emptyCompletionError(incompleteReason);
   return out;
 }
@@ -159,15 +209,20 @@ export async function* codexResponsesStream(
   if (!response.body) return;
   let yieldedAny = false;
   let incompleteReason: string | undefined;
+  const toolAcc = new Map<number, { name: string; args: string }>();
   for await (const data of readSse(response.body)) {
     const ev = parseResponsesEvent(data);
     if (ev.delta) {
       yieldedAny = true;
       yield ev.delta;
     }
+    accumulateResponsesToolCall(toolAcc, ev);
     if (ev.usage) options.onUsage?.(ev.usage);
     if (ev.incompleteReason) incompleteReason = ev.incompleteReason;
     if (ev.error) throw new Error(`OpenAI Codex response failed: ${ev.error}`);
   }
+  // Native tool calls have no output_text deltas — yield the re-serialized envelope once.
+  const envelope = serializeResponsesToolCalls(toolAcc);
+  if (envelope) { yieldedAny = true; yield envelope; }
   if (!yieldedAny) throw emptyCompletionError(incompleteReason);
 }

package/src/ai/providers/openai.ts

@@ -3,6 +3,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
+import { serializeToolCalls } from "../../agent/tool-schemas";
 
 export function openaiRequest(messages: Message[], options: CallOptions, credential: Credential, stream: boolean): { url: string; headers: Record<string, string>; body: string } {
   const model = options.model.startsWith("openai/") ? options.model.slice(7) : options.model;
@@ -39,7 +40,11 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
     payload.stream = true;
     payload.stream_options = { include_usage: true };
   }
-  if (options.jsonMode) payload.response_format = { type: "json_object" };
+  if (options.tools?.length) {
+    payload.tools = options.tools.map(t => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+    payload.tool_choice = "auto";
+  }
+  if (options.jsonMode && !options.tools?.length) payload.response_format = { type: "json_object" };
   const base = (options.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1").replace(/\/$/, "");
   return {
     url: `${base}/chat/completions`,
@@ -59,14 +64,18 @@ function emptyCompletionError(finishReason: string | undefined): Error {
 
 export const openaiAdapter: ProviderAdapter = {
   name: "openai",
+  supportsNativeTools: true,
   async call(messages, options, credential) {
     // ChatGPT/Codex OAuth can't use /chat/completions — route to the Codex Responses backend.
     if (credential.kind === "oauth") return codexResponsesCall(messages, options, credential);
     const { url, headers, body } = openaiRequest(messages, options, credential, false);
     const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("OpenAI", response);
-    const result = (await response.json()) as { choices: { message: { content: string }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
+    const result = (await response.json()) as { choices: { message: { content?: string; tool_calls?: { function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
     if (result.usage) options.onUsage?.({ inputTokens: result.usage.prompt_tokens, outputTokens: result.usage.completion_tokens });
+    // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
+    const envelope = serializeToolCalls(parseOpenaiToolCalls(result.choices[0]?.message?.tool_calls));
+    if (envelope) return envelope;
     const text = result.choices[0]?.message?.content ?? "";
     if (!text) throw emptyCompletionError(result.choices[0]?.finish_reason);
     return text;
@@ -93,8 +102,9 @@ export const openaiAdapter: ProviderAdapter = {
     if (!response.body) return;
     let yieldedAny = false;
     let finishReason: string | undefined;
+    const toolAcc = new Map<number, { name: string; args: string }>();
     for await (const data of readSse(response.body)) {
-      let chunk: { choices?: { delta?: { content?: string }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
+      let chunk: { choices?: { delta?: { content?: string; tool_calls?: { index?: number; function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
       try {
         chunk = JSON.parse(data);
       } catch {
@@ -105,13 +115,46 @@ export const openaiAdapter: ProviderAdapter = {
         yieldedAny = true;
         yield delta;
       }
+      const tcs = chunk.choices?.[0]?.delta?.tool_calls;
+      if (tcs) {
+        for (const tc of tcs) {
+          const idx = tc.index ?? 0;
+          const b = toolAcc.get(idx) ?? { name: "", args: "" };
+          if (tc.function?.name) b.name = tc.function.name;
+          if (tc.function?.arguments) b.args += tc.function.arguments;
+          toolAcc.set(idx, b);
+        }
+      }
       if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
       if (chunk.usage) options.onUsage?.({ inputTokens: chunk.usage.prompt_tokens, outputTokens: chunk.usage.completion_tokens });
     }
+    // Native tool calls stream as tool_calls argument fragments — re-serialize once at end.
+    if (toolAcc.size > 0) {
+      const calls = [...toolAcc.values()].map(b => {
+        let args: Record<string, unknown> = {};
+        try { args = b.args ? JSON.parse(b.args) : {}; } catch { args = {}; }
+        return { tool: b.name, arguments: args };
+      });
+      const envelope = serializeToolCalls(calls);
+      if (envelope) { yieldedAny = true; yield envelope; }
+    }
     if (!yieldedAny) throw emptyCompletionError(finishReason);
   },
 };
 
+function parseOpenaiToolCalls(toolCalls: { function?: { name?: string; arguments?: string } }[] | undefined): { tool: string; arguments: Record<string, unknown> }[] {
+  if (!toolCalls?.length) return [];
+  const out: { tool: string; arguments: Record<string, unknown> }[] = [];
+  for (const tc of toolCalls) {
+    const name = tc.function?.name;
+    if (!name) continue;
+    let args: Record<string, unknown> = {};
+    try { args = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {}; } catch { args = {}; }
+    out.push({ tool: name, arguments: args });
+  }
+  return out;
+}
+
 function bearerFor(credential: Credential): string {
   if (credential.kind === "oauth") return credential.token;
   if (credential.kind === "api_key") return credential.token;

package/src/ai/types.ts

@@ -26,6 +26,16 @@ export interface Usage {
   durationMs?: number;
 }
 
+/** Provider-neutral function/tool schema for NATIVE tool-calling. Capable adapters
+ *  (anthropic/openai/gemini) map this onto their wire format (Anthropic input_schema,
+ *  OpenAI function.parameters, Gemini functionDeclarations); fallback adapters
+ *  (antigravity/ollama) ignore it and keep the JSON-in-prose protocol. */
+export interface NativeToolSchema {
+  name: string;
+  description: string;
+  parameters: { type: "object"; properties: Record<string, unknown>; required?: string[] };
+}
+
 export interface CallOptions {
   model: string;
   systemPrompt?: string;
@@ -47,10 +57,19 @@ export interface CallOptions {
    *  answer text). Surfaced as a transient dimmed view; absent for models that emit no
    *  thought text. */
   onReasoning?: (delta: string) => void;
+  /** NATIVE tool-calling: function declarations the model may call. Present only on the
+   *  main agent step (never the prose wrap-up). Adapters with `supportsNativeTools` send
+   *  these on the wire and re-serialize the structured tool call back into the engine's
+   *  canonical {"tool":...}/{"tools":[...]} string; others ignore it. */
+  tools?: NativeToolSchema[];
 }
 
 export interface ProviderAdapter {
   readonly name: ProviderName;
+  /** True when this adapter implements native function-calling (re-serialized to the
+   *  canonical JSON string). When false/absent, `CallOptions.tools` is ignored and the
+   *  model drives tools via the JSON-in-prose protocol. */
+  readonly supportsNativeTools?: boolean;
   /** Local providers ignore the credential argument; cloud adapters require it. */
   call(messages: Message[], options: CallOptions, credential: Credential): Promise<string>;
   /** Optional token streaming. Yields text deltas; concatenation equals the `call()` result. */

package/src/cli/runner.ts

@@ -172,6 +172,15 @@ export const COMMANDS: readonly CommandSpec[] = [
       return args => m.runUpdateCommand(args);
     },
   },
+  {
+    name: "whats-new",
+    summary: "Show the release notes bundled with the installed jeo-code version.",
+    usage: "whats-new [--all] [--json]",
+    loader: async () => {
+      const m = await import("../commands/whats-new");
+      return args => m.runWhatsNewCommand(args);
+    },
+  },
   {
     name: "ooo-seed",
     summary: "Generate an immutable ooo seed from a specification (spec-first automation).",