baro-ai 0.29.0 → 0.30.1

package/dist/cli.mjs

@@ -7160,6 +7160,46 @@ OpenAI.Skills = Skills;
 OpenAI.Videos = Videos;
 
 // ../../node_modules/@mozaik-ai/core/dist/index.mjs
+var ModelContext = class _ModelContext {
+  constructor(id, projectId, items) {
+    this.projectId = projectId;
+    this.id = id;
+    this.items = items;
+  }
+  addContextItem(item) {
+    this.items.push(item);
+    return this;
+  }
+  applyModelOutput(items) {
+    for (const item of items) {
+      const itemType = item.getType();
+      if (itemType !== "function_call" && itemType !== "message" && itemType !== "reasoning") {
+        throw new Error(`Invalid item type: ${itemType}`);
+      }
+    }
+    this.items.push(...items);
+    return this;
+  }
+  getItems() {
+    return this.items;
+  }
+  getLastItem() {
+    if (this.items.length === 0) {
+      throw new Error("No items in context");
+    }
+    return this.items[this.items.length - 1];
+  }
+  static create(projectId) {
+    const id = crypto.randomUUID();
+    return new _ModelContext(id, projectId, []);
+  }
+  static rehydrate(data) {
+    return new _ModelContext(data.id, data.projectId, data.items);
+  }
+  toJSON() {
+    return this.items.map((item) => item.toJSON());
+  }
+};
 var ContextItem = class {
   getType() {
     return this.type;
@@ -7188,6 +7228,29 @@ var InputText = class _InputText extends ItemContent {
     ];
   }
 };
+var UserMessageItem = class _UserMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "user";
+    this.content = content;
+  }
+  static create(text) {
+    const content = InputText.create(text);
+    return new _UserMessageItem(content);
+  }
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _UserMessageItem(content);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      role: this.role,
+      content: this.content.toJSON()
+    };
+  }
+};
 var OutputText = class _OutputText extends ItemContent {
   constructor(text) {
     super();
@@ -7245,6 +7308,27 @@ var FunctionCallItem = class _FunctionCallItem extends ContextItem {
     };
   }
 };
+var ReasoningItem = class _ReasoningItem extends ContextItem {
+  constructor(content, encryptedContent, summary = []) {
+    super();
+    this.type = "reasoning";
+    this.content = content;
+    this.encryptedContent = encryptedContent;
+    this.summary = summary;
+  }
+  static rehydrate(data) {
+    return new _ReasoningItem(data.content, data.encryptedContent, data.summary);
+  }
+  toJSON() {
+    var _a3;
+    return {
+      type: this.type,
+      content: (_a3 = this.content) == null ? void 0 : _a3.toJSON(),
+      encryptedContent: this.encryptedContent,
+      summary: this.summary.map((s) => s.toJSON())
+    };
+  }
+};
 var FunctionCallOutputItem = class _FunctionCallOutputItem extends ContextItem {
   constructor(callId, output) {
     super();
@@ -7267,6 +7351,225 @@ var FunctionCallOutputItem = class _FunctionCallOutputItem extends ContextItem {
     };
   }
 };
+var InferenceResponse = class {
+  constructor(contextItems, tokenUsage) {
+    this.contextItems = contextItems;
+    this.tokenUsage = tokenUsage;
+  }
+};
+var InputTokenDetails = class {
+  constructor(cached_tokens) {
+    this.cached_tokens = cached_tokens;
+  }
+};
+var OutputTokenDetails = class {
+  constructor(reasoning_tokens) {
+    this.reasoning_tokens = reasoning_tokens;
+  }
+};
+var TokenUsage = class {
+  constructor(inputTokens, outputTokens, totalTokens, inputTokenDetails, outputTokenDetails) {
+    this.inputTokens = inputTokens;
+    this.outputTokens = outputTokens;
+    this.totalTokens = totalTokens;
+    this.inputTokenDetails = inputTokenDetails;
+    this.outputTokenDetails = outputTokenDetails;
+  }
+};
+var OpenAIResponses = class {
+  constructor() {
+    this.client = new OpenAI();
+  }
+  async infer(inferenceRequest) {
+    const input = this.mapContextToRequest(inferenceRequest.context);
+    const specification = inferenceRequest.model.specification;
+    let request = {
+      model: specification.name,
+      input
+    };
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      request.tools = inferenceRequest.model.getTools().map((tool) => {
+        return {
+          type: tool.type,
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        };
+      });
+    }
+    if (specification.supportReasoningEffort) {
+      request.reasoning = {
+        effort: inferenceRequest.model.getReasoningEffort()
+      };
+    }
+    const response = await this.client.responses.create(request);
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  extractTokenUsage(response) {
+    if (!response.usage) {
+      return void 0;
+    }
+    return new TokenUsage(
+      response.usage.input_tokens,
+      response.usage.output_tokens,
+      response.usage.total_tokens,
+      new InputTokenDetails(response.usage.input_tokens_details.cached_tokens),
+      new OutputTokenDetails(response.usage.output_tokens_details.reasoning_tokens)
+    );
+  }
+  mapContextToRequest(context) {
+    return context.getItems().map((item) => item.toJSON());
+  }
+  extractContextItems(response) {
+    return response.output.map((item) => {
+      if (item.type === "message" && item.role === "assistant") {
+        return ModelMessageItem.rehydrate(item.content[0]);
+      }
+      if (item.type === "function_call") {
+        return FunctionCallItem.rehydrate({
+          callId: item.call_id,
+          name: item.name,
+          args: item.arguments
+        });
+      }
+      if (item.type === "reasoning") {
+        return ReasoningItem.rehydrate(item);
+      }
+    });
+  }
+};
+var InferenceRequest = class {
+  constructor(model, context) {
+    this.model = model;
+    this.context = context;
+  }
+};
+var OpenAIReasoningEffort = class {
+  constructor(reasoningEffort) {
+    this.reasoningEffort = reasoningEffort;
+  }
+  setReasoningEffort(effort) {
+    this.reasoningEffort = effort;
+  }
+  getReasoningEffort() {
+    if (!this.reasoningEffort) {
+      throw new Error("Reasoning effort not supported");
+    }
+    return this.reasoningEffort;
+  }
+};
+var Gpt54Nano = class {
+  constructor() {
+    this.specification = {
+      name: "gpt-5.4-nano",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 4e5,
+      maxOutputTokens: 128e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.effort = new OpenAIReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+};
+var Gpt54 = class {
+  constructor() {
+    this.specification = {
+      name: "gpt-5.4",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 105e4,
+      maxOutputTokens: 128e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.effort = new OpenAIReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+};
+var Gpt54Mini = class {
+  constructor() {
+    this.specification = {
+      name: "gpt-5.4-mini",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 4e5,
+      maxOutputTokens: 128e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.effort = new OpenAIReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+};
+var SystemMessageItem = class _SystemMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "system";
+    this.content = content;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      role: this.role,
+      content: this.content.toJSON()
+    };
+  }
+  static create(text) {
+    const content = InputText.create(text);
+    return new _SystemMessageItem(content);
+  }
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _SystemMessageItem(content);
+  }
+};
 var Participant = class {
   constructor() {
     this.environments = [];
@@ -7369,6 +7672,46 @@ var AgenticEnvironment = class {
     this.isActive = false;
   }
 };
+var OpenAIInferenceRunner = class {
+  constructor() {
+    this.runtime = new OpenAIResponses();
+  }
+  async *run(context, model, signal) {
+    const response = await this.runtime.infer(new InferenceRequest(model, context));
+    for (const item of response.contextItems) {
+      yield item;
+    }
+  }
+};
+var Gpt55 = class {
+  constructor() {
+    this.specification = {
+      name: "gpt-5.5",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 105e4,
+      maxOutputTokens: 128e3,
+      supportFunctionCalling: true
+    };
+    this.tools = [];
+    this.effort = new OpenAIReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+};
 
 // ../baro-orchestrator/src/bus.ts
 var BusEvent = class {
@@ -9533,6 +9876,124 @@ function extractVerdictJson(text) {
   throw new Error(`unbalanced JSON object in critic response: ${trimmed.slice(0, 200)}`);
 }
 
+// ../baro-orchestrator/src/participants/critic-openai.ts
+function pickModel(name) {
+  switch (name) {
+    case "gpt-5.5":
+      return new Gpt55();
+    case "gpt-5.4":
+      return new Gpt54();
+    case "gpt-5.4-mini":
+      return new Gpt54Mini();
+    case "gpt-5.4-nano":
+      return new Gpt54Nano();
+    default:
+      throw new Error(
+        `CriticOpenAI: unknown model "${name}" \u2014 Mozaik 3.9 ships gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.4-nano`
+      );
+  }
+}
+var CriticOpenAI = class extends BaroParticipant {
+  opts;
+  model;
+  runner = new OpenAIInferenceRunner();
+  emissions = /* @__PURE__ */ new Map();
+  turnCount = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    super();
+    this.opts = {
+      maxEmissionsPerAgent: opts.maxEmissionsPerAgent ?? 2,
+      model: opts.model ?? "gpt-5.4-mini",
+      targets: opts.targets
+    };
+    this.model = pickModel(this.opts.model);
+  }
+  /** Resolves once every in-flight evaluation has emitted its CritiqueItem. */
+  async idle() {
+    await Promise.allSettled([...this.pending]);
+  }
+  async onExternalBusEvent(_source, event) {
+    if (!(event instanceof ClaudeResultItem)) return;
+    if (event.isError || !event.resultText) return;
+    const criteria = this.opts.targets.get(event.agentId);
+    if (!criteria || criteria.length === 0) return;
+    const turn = (this.turnCount.get(event.agentId) ?? 0) + 1;
+    this.turnCount.set(event.agentId, turn);
+    const work = (async () => {
+      const { verdict, reasoning, violatedCriteria } = await this.evaluate(
+        event.resultText,
+        criteria
+      );
+      const critiqueItem = new CritiqueItem(
+        event.agentId,
+        verdict,
+        reasoning,
+        violatedCriteria,
+        turn,
+        this.opts.model
+      );
+      for (const env of this.getEnvironments()) {
+        ;
+        env.deliverBusEvent(this, critiqueItem);
+      }
+      if (verdict === "fail") {
+        const emitted = this.emissions.get(event.agentId) ?? 0;
+        if (emitted < this.opts.maxEmissionsPerAgent) {
+          this.emissions.set(event.agentId, emitted + 1);
+          const text = buildCorrectiveMessage(reasoning, violatedCriteria);
+          const msg = new AgentTargetedMessageItem(event.agentId, text, {
+            criticTurn: turn,
+            emissionIndex: emitted + 1
+          });
+          for (const env of this.getEnvironments()) {
+            ;
+            env.deliverBusEvent(this, msg);
+          }
+        }
+      }
+    })();
+    this.pending.add(work);
+    work.finally(() => this.pending.delete(work));
+  }
+  /**
+   * One-shot OpenAI inference call. Builds a ModelContext with the
+   * verdict system prompt + the eval prompt, runs the inference, and
+   * parses the JSON verdict the model returned. Same prompt and same
+   * JSON shape as the Claude version so behaviour stays comparable
+   * for benchmarking.
+   */
+  async evaluate(resultText, criteria) {
+    const userPrompt = buildEvalPrompt(criteria, resultText);
+    const context = ModelContext.create("critic").addContextItem(SystemMessageItem.create(VERDICT_SYSTEM_PROMPT)).addContextItem(UserMessageItem.create(userPrompt));
+    try {
+      let assistantText = "";
+      for await (const item of this.runner.run(context, this.model)) {
+        if (item.type === "message" && item.role === "assistant") {
+          const json = item.toJSON();
+          assistantText += json.content?.[0]?.text ?? "";
+        }
+      }
+      if (!assistantText.trim()) {
+        throw new Error("OpenAI returned empty assistant text");
+      }
+      const verdictJson = extractVerdictJson(assistantText);
+      const parsed = JSON.parse(verdictJson);
+      return {
+        verdict: parsed.verdict === "pass" ? "pass" : "fail",
+        reasoning: parsed.reasoning ?? "",
+        violatedCriteria: Array.isArray(parsed.violated_criteria) ? parsed.violated_criteria : []
+      };
+    } catch (err) {
+      return {
+        verdict: "fail",
+        reasoning: `Critic (OpenAI) LLM call failed: ${String(err?.message ?? err)}`,
+        violatedCriteria: ["[critic-openai error \u2014 could not evaluate]"]
+      };
+    }
+  }
+};
+
 // ../baro-orchestrator/src/participants/finalizer.ts
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
@@ -10482,13 +10943,7 @@ var Surgeon = class extends BaroParticipant {
    * skipping (if their only dep is now gone, they become unreachable).
    */
   evaluateDeterministic(failure) {
-    return new ReplanItem(
-      "surgeon",
-      `deterministic skip: ${failure.storyId} exhausted ${failure.attempts} attempts (${failure.error ?? "no reason"})`,
-      [],
-      [failure.storyId],
-      /* @__PURE__ */ new Map()
-    );
+    return surgeonDeterministicReplan(failure);
   }
   /**
    * LLM strategy: ask Claude (via CLI subprocess) to propose a replan
@@ -10593,6 +11048,118 @@ function extractJsonObject(text) {
   }
   throw new Error("unbalanced JSON object in surgeon response");
 }
+function surgeonDeterministicReplan(failure) {
+  return new ReplanItem(
+    "surgeon",
+    `deterministic skip: ${failure.storyId} exhausted ${failure.attempts} attempts (${failure.error ?? "no reason"})`,
+    [],
+    [failure.storyId],
+    /* @__PURE__ */ new Map()
+  );
+}
+
+// ../baro-orchestrator/src/participants/surgeon-openai.ts
+function pickModel2(name) {
+  switch (name) {
+    case "gpt-5.5":
+      return new Gpt55();
+    case "gpt-5.4":
+      return new Gpt54();
+    case "gpt-5.4-mini":
+      return new Gpt54Mini();
+    case "gpt-5.4-nano":
+      return new Gpt54Nano();
+    default:
+      throw new Error(
+        `SurgeonOpenAI: unknown model "${name}" \u2014 Mozaik 3.9 ships gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.4-nano`
+      );
+  }
+}
+var SurgeonOpenAI = class extends BaroParticipant {
+  opts;
+  model;
+  runner = new OpenAIInferenceRunner();
+  replansEmitted = 0;
+  pending = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    super();
+    this.opts = {
+      maxReplans: opts.maxReplans ?? 10,
+      model: opts.model ?? "gpt-5.4",
+      snapshot: opts.snapshot
+    };
+    this.model = pickModel2(this.opts.model);
+  }
+  async idle() {
+    await Promise.allSettled([...this.pending]);
+  }
+  async onExternalBusEvent(_source, event) {
+    if (!(event instanceof StoryResultItem)) return;
+    if (event.success) return;
+    if (this.replansEmitted >= this.opts.maxReplans) return;
+    const work = (async () => {
+      const replan = await this.evaluate(event);
+      if (!replan) return;
+      this.replansEmitted += 1;
+      for (const env of this.getEnvironments()) {
+        ;
+        env.deliverBusEvent(this, replan);
+      }
+    })();
+    this.pending.add(work);
+    work.finally(() => this.pending.delete(work));
+    await work;
+  }
+  /**
+   * One-shot OpenAI inference call asking the model for a structured
+   * replan. Returns `null` on the "abort" action (no ReplanItem
+   * emitted, run ends). Returns a deterministic-skip `ReplanItem` on
+   * any inference or JSON-parse error so the run still has a chance
+   * to recover.
+   */
+  async evaluate(failure) {
+    const snap = this.opts.snapshot();
+    const userPrompt = buildSurgeonPrompt(snap, failure);
+    const context = ModelContext.create("surgeon").addContextItem(SystemMessageItem.create(SURGEON_SYSTEM_PROMPT)).addContextItem(UserMessageItem.create(userPrompt));
+    try {
+      let assistantText = "";
+      for await (const item of this.runner.run(context, this.model)) {
+        if (item.type === "message" && item.role === "assistant") {
+          const json = item.toJSON();
+          assistantText += json.content?.[0]?.text ?? "";
+        }
+      }
+      if (!assistantText.trim()) {
+        throw new Error("OpenAI returned empty assistant text");
+      }
+      const verdictJson = extractJsonObject(assistantText);
+      const parsed = JSON.parse(verdictJson);
+      if (parsed.action === "abort") return null;
+      const modifiedDeps = /* @__PURE__ */ new Map();
+      for (const m of parsed.modifiedDeps ?? []) {
+        if (typeof m.id === "string" && Array.isArray(m.newDependsOn)) {
+          modifiedDeps.set(m.id, [...m.newDependsOn]);
+        }
+      }
+      return new ReplanItem(
+        "surgeon",
+        `${parsed.action}: ${parsed.reason ?? ""}`,
+        parsed.added ?? [],
+        parsed.removed ?? [],
+        modifiedDeps
+      );
+    } catch (err) {
+      const fallback = surgeonDeterministicReplan(failure);
+      return new ReplanItem(
+        fallback.source,
+        `${fallback.reason} (openai-llm fallback after error: ${err?.message ?? String(err)})`,
+        fallback.addedStories,
+        fallback.removedStoryIds,
+        fallback.modifiedDeps
+      );
+    }
+  }
+};
 
 // ../baro-orchestrator/src/tui-protocol.ts
 function emit(event) {
@@ -10607,7 +11174,7 @@ async function orchestrate(config) {
   const llm = config.llm ?? "claude";
   if (llm === "openai") {
     process.stderr.write(
-      "[orchestrate] llm=openai requested \u2014 no native OpenAI siblings wired yet, falling through to Claude CLI flow. Coming in 0.29+.\n"
+      "[orchestrate] llm=openai: Critic + Surgeon route to Mozaik OpenAI; Architect, Planner, StoryAgent still on Claude CLI (per-phase ports in 0.31+).\n"
     );
   }
   if (config.auditLogPath) {
@@ -10634,21 +11201,25 @@ async function orchestrate(config) {
   if (sentry) sentry.join(env);
   let surgeon = null;
   if (config.withSurgeon) {
-    surgeon = new Surgeon({
-      snapshot: () => {
-        const current = loadPrd(config.prdPath);
-        return {
-          project: current.project,
-          description: current.description,
-          stories: current.userStories.map((s) => ({
-            id: s.id,
-            title: s.title,
-            description: s.description,
-            dependsOn: s.dependsOn,
-            passes: s.passes
-          }))
-        };
-      },
+    const snapshot = () => {
+      const current = loadPrd(config.prdPath);
+      return {
+        project: current.project,
+        description: current.description,
+        stories: current.userStories.map((s) => ({
+          id: s.id,
+          title: s.title,
+          description: s.description,
+          dependsOn: s.dependsOn,
+          passes: s.passes
+        }))
+      };
+    };
+    surgeon = llm === "openai" ? new SurgeonOpenAI({
+      snapshot,
+      model: config.surgeonModel ?? "gpt-5.4"
+    }) : new Surgeon({
+      snapshot,
       useLlm: config.surgeonUseLlm ?? false,
       model: config.surgeonModel ?? "opus"
     });
@@ -10660,7 +11231,10 @@ async function orchestrate(config) {
     const targets = new Map(
       prd.userStories.filter((s) => s.acceptance && s.acceptance.length > 0).map((s) => [s.id, s.acceptance])
     );
-    critic = new Critic({
+    critic = llm === "openai" ? new CriticOpenAI({
+      targets,
+      model: config.criticModel ?? "gpt-5.4-mini"
+    }) : new Critic({
       targets,
       model: config.criticModel ?? "haiku"
     });