@goah/cli 0.13.0 → 0.13.2

package/dist/faux-runner-worker.js

@@ -0,0 +1,128 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  runProcessWorker
+} from "./chunk-7E7V6OIU.js";
+import "./chunk-6M3OOCKO.js";
+import "./chunk-K26BVR6O.js";
+import "./chunk-IIJQ3DW4.js";
+import "./chunk-2ZP2NBW3.js";
+import "./chunk-MPXK7QBL.js";
+import "./chunk-2QBQZGXF.js";
+import "./chunk-4KA63VNZ.js";
+import "./chunk-KAO7WIXG.js";
+import "./chunk-R6I3VKME.js";
+import "./chunk-TJON22J4.js";
+import "./chunk-XPQKM3L7.js";
+
+// node_modules/goah-testkit/dist/faux-runner-worker.js
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+await runProcessWorker(async (request, emit, rpc) => {
+  if (process.env.GOAH_FAUX_CONTEXT_FILE)
+    writeFileSync(process.env.GOAH_FAUX_CONTEXT_FILE, JSON.stringify(request.context));
+  const byAgent = JSON.parse(process.env.GOAH_FAUX_STEPS_BY_AGENT ?? "{}");
+  const byTrigger = JSON.parse(process.env.GOAH_FAUX_STEPS_BY_TRIGGER ?? "{}");
+  const triggerSteps = Object.entries(byTrigger).find(([selector]) => {
+    const separator = selector.indexOf("|");
+    const agent = separator < 0 ? null : selector.slice(0, separator);
+    const prefix = separator < 0 ? selector : selector.slice(separator + 1);
+    return (!agent || agent === request.agent) && request.sourceWakeTriggers?.some((trigger) => trigger.triggerRef.startsWith(prefix));
+  })?.[1];
+  const steps = triggerSteps ?? byAgent[request.agent] ?? JSON.parse(process.env.GOAH_FAUX_STEPS ?? "[]");
+  let goalCommitment = request.turn?.goalCommitment;
+  let recordUpdated = false;
+  for (const step of steps) {
+    if (step.write) {
+      const path = join(process.cwd(), step.write.path);
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, step.write.content);
+    }
+    for (const trace of step.trace ?? [])
+      emit(trace);
+    if (step.rpc) {
+      const result = await rpc(step.rpc.method, resolveParams(step.rpc.params, request.context));
+      emit({ type: "runner.rpc.result", data: result });
+      if (step.rpc.method === "goal.create" || step.rpc.method === "goal.work")
+        goalCommitment = commitmentFrom(result) ?? goalCommitment;
+      if (step.rpc.method === "work_record.update")
+        recordUpdated = true;
+    }
+    if (step.crash)
+      throw new Error(step.crash);
+    if (step.delayMs)
+      await new Promise((resolve) => setTimeout(resolve, step.delayMs));
+    if (step.hang)
+      await new Promise(() => void 0);
+    if (step.response !== void 0)
+      return { outcome: "completed", response: { content: step.response } };
+    if (step.handoff) {
+      const draft = step.handoff;
+      if (goalCommitment && !recordUpdated) {
+        const current = await rpc("work_record.read", { goalId: goalCommitment.goalId });
+        const record = current && typeof current === "object" && !Array.isArray(current) ? current : {};
+        const evidence = sourceSeqs(request.context);
+        await rpc("work_record.update", { expectedRevision: Number(record.recordRevision ?? 0), content: handoffRecord(draft.handoff, request.execution.id), reason: "record faux Goal progress", evidence: evidence.length ? [Math.max(...evidence)] : [] });
+      }
+      const validation = await rpc("goal.handoff.validate", { handoff: draft.handoff, candidateMessage: draft.response.content });
+      emit({ type: "message.assistant.completed", data: { message: { id: `faux:${request.execution.id}:handoff:${validation.attemptId}`, role: "assistant", content: [{ type: "text", text: draft.response.content }], stopReason: "toolUse" }, commitState: "provisional" } });
+      if (!validation.accepted) {
+        emit({ type: "runner.handoff_rejected", data: { attemptId: validation.attemptId, issues: validation.issues } });
+        if (validation.fatal)
+          return { outcome: "abnormal", reason: validation.issues.map((issue) => issue.message).join("; ") };
+        continue;
+      }
+      const output = { validationAttemptId: validation.attemptId, validationToken: validation.token, handoff: draft.handoff };
+      return { outcome: "completed", response: draft.response, handoff: output };
+    }
+  }
+  return { outcome: "abnormal", reason: "faux worker stopped without handoff" };
+});
+function resolveParams(value, context) {
+  const latest = Math.max(0, ...sourceSeqs(context));
+  const visit = (item) => {
+    if (item === "$LATEST_SOURCE_SEQ")
+      return latest;
+    if (Array.isArray(item))
+      return item.map(visit);
+    if (item && typeof item === "object")
+      return Object.fromEntries(Object.entries(item).map(([key, nested]) => [key, visit(nested)]));
+    return item;
+  };
+  return visit(value);
+}
+function sourceSeqs(context) {
+  return context && typeof context === "object" && !Array.isArray(context) && Array.isArray(context.sourceSeqs) ? context.sourceSeqs.filter((item) => typeof item === "number") : [];
+}
+function commitmentFrom(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || !value.goalCommitment || typeof value.goalCommitment !== "object" || Array.isArray(value.goalCommitment))
+    return void 0;
+  const binding = value.goalCommitment;
+  return typeof binding.goalId === "string" && typeof binding.goalRevision === "number" ? { goalId: binding.goalId, goalRevision: binding.goalRevision } : void 0;
+}
+function handoffRecord(handoff, turnId) {
+  return `# Current State
+
+Goal outcome: ${handoff.outcome}.
+
+# Observations
+
+See Ledger evidence ${handoff.evidence.join(", ") || "none"}.
+
+# Work Completed
+
+Recorded Goal progress.
+
+# Decisions
+
+Recorded by the faux Goal runner in ${turnId}.
+
+# Blockers
+
+${handoff.outcome === "blocked" ? "Blocked." : "None."}
+
+# Next Steps
+
+Continue from the current Goal state.
+`;
+}

package/dist/google-generative-ai-YMHXZSFE.js

@@ -0,0 +1,422 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+import {
+  GoogleGenAI,
+  convertMessages,
+  convertTools,
+  isThinkingPart,
+  mapStopReason,
+  resolveGoogleFunctionCallingMode,
+  retainThoughtSignature,
+  retryGoogleRequest,
+  supportsGoogleStrictToolSampling
+} from "./chunk-ULY36ME4.js";
+import {
+  formatProviderError,
+  normalizeProviderError
+} from "./chunk-H462EFJP.js";
+import {
+  buildBaseOptions
+} from "./chunk-BXA47DTF.js";
+import "./chunk-4M6TXTT5.js";
+import {
+  sanitizeSurrogates
+} from "./chunk-NRLGWZJC.js";
+import {
+  providerHeadersToRecord
+} from "./chunk-FSBUS2BI.js";
+import {
+  calculateCost,
+  clampThinkingLevel
+} from "./chunk-MPXK7QBL.js";
+import {
+  AssistantMessageEventStream
+} from "./chunk-2QBQZGXF.js";
+import "./chunk-XPQKM3L7.js";
+
+// ../../node_modules/@earendil-works/pi-ai/dist/api/google-generative-ai.js
+var toolCallCounter = 0;
+var stream = (model, context, options) => {
+  const stream2 = new AssistantMessageEventStream();
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: "google-generative-ai",
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    try {
+      if (options?.fetch && options.fetch !== globalThis.fetch) {
+        throw new Error("Custom fetch is not supported by the Google Generative AI adapter");
+      }
+      const apiKey = options?.apiKey;
+      if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
+      }
+      const client = createClient(model, apiKey, options?.headers);
+      let params = buildParams(model, context, options);
+      const nextParams = await options?.onPayload?.(params, model);
+      if (nextParams !== void 0) {
+        params = nextParams;
+      }
+      const googleStream = await retryGoogleRequest(() => client.models.generateContentStream(params), options);
+      stream2.push({ type: "start", partial: output });
+      let currentBlock = null;
+      const blocks = output.content;
+      const blockIndex = () => blocks.length - 1;
+      for await (const chunk of googleStream) {
+        output.responseId ||= chunk.responseId;
+        const candidate = chunk.candidates?.[0];
+        if (candidate?.content?.parts) {
+          for (const part of candidate.content.parts) {
+            if (part.text !== void 0) {
+              const isThinking = isThinkingPart(part);
+              if (!currentBlock || isThinking && currentBlock.type !== "thinking" || !isThinking && currentBlock.type !== "text") {
+                if (currentBlock) {
+                  if (currentBlock.type === "text") {
+                    stream2.push({
+                      type: "text_end",
+                      contentIndex: blocks.length - 1,
+                      content: currentBlock.text,
+                      partial: output
+                    });
+                  } else {
+                    stream2.push({
+                      type: "thinking_end",
+                      contentIndex: blockIndex(),
+                      content: currentBlock.thinking,
+                      partial: output
+                    });
+                  }
+                }
+                if (isThinking) {
+                  currentBlock = { type: "thinking", thinking: "", thinkingSignature: void 0 };
+                  output.content.push(currentBlock);
+                  stream2.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+                } else {
+                  currentBlock = { type: "text", text: "" };
+                  output.content.push(currentBlock);
+                  stream2.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+                }
+              }
+              if (currentBlock.type === "thinking") {
+                currentBlock.thinking += part.text;
+                currentBlock.thinkingSignature = retainThoughtSignature(currentBlock.thinkingSignature, part.thoughtSignature);
+                stream2.push({
+                  type: "thinking_delta",
+                  contentIndex: blockIndex(),
+                  delta: part.text,
+                  partial: output
+                });
+              } else {
+                currentBlock.text += part.text;
+                currentBlock.textSignature = retainThoughtSignature(currentBlock.textSignature, part.thoughtSignature);
+                stream2.push({
+                  type: "text_delta",
+                  contentIndex: blockIndex(),
+                  delta: part.text,
+                  partial: output
+                });
+              }
+            }
+            if (part.functionCall) {
+              if (currentBlock) {
+                if (currentBlock.type === "text") {
+                  stream2.push({
+                    type: "text_end",
+                    contentIndex: blockIndex(),
+                    content: currentBlock.text,
+                    partial: output
+                  });
+                } else {
+                  stream2.push({
+                    type: "thinking_end",
+                    contentIndex: blockIndex(),
+                    content: currentBlock.thinking,
+                    partial: output
+                  });
+                }
+                currentBlock = null;
+              }
+              const providedId = part.functionCall.id;
+              const needsNewId = !providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
+              const toolCallId = needsNewId ? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}` : providedId;
+              const toolCall = {
+                type: "toolCall",
+                id: toolCallId,
+                name: part.functionCall.name || "",
+                arguments: part.functionCall.args ?? {},
+                ...part.thoughtSignature && { thoughtSignature: part.thoughtSignature }
+              };
+              output.content.push(toolCall);
+              stream2.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+              stream2.push({
+                type: "toolcall_delta",
+                contentIndex: blockIndex(),
+                delta: JSON.stringify(toolCall.arguments),
+                partial: output
+              });
+              stream2.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+            }
+          }
+        }
+        if (candidate?.finishReason) {
+          output.rawStopReason = candidate.finishReason;
+          output.stopReason = mapStopReason(candidate.finishReason);
+          if (output.content.some((b) => b.type === "toolCall") && output.stopReason === "stop") {
+            output.stopReason = "toolUse";
+          }
+        }
+        if (chunk.usageMetadata) {
+          output.usage = {
+            input: (chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
+            output: (chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+            cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
+            cacheWrite: 0,
+            reasoning: chunk.usageMetadata.thoughtsTokenCount || 0,
+            totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+            cost: {
+              input: 0,
+              output: 0,
+              cacheRead: 0,
+              cacheWrite: 0,
+              total: 0
+            }
+          };
+          calculateCost(model, output.usage);
+        }
+      }
+      if (currentBlock) {
+        if (currentBlock.type === "text") {
+          stream2.push({
+            type: "text_end",
+            contentIndex: blockIndex(),
+            content: currentBlock.text,
+            partial: output
+          });
+        } else {
+          stream2.push({
+            type: "thinking_end",
+            contentIndex: blockIndex(),
+            content: currentBlock.thinking,
+            partial: output
+          });
+        }
+      }
+      if (options?.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (output.stopReason === "pending") {
+        throw new Error("Google stream ended without a finish reason");
+      }
+      if (output.stopReason === "aborted" || output.stopReason === "error") {
+        const errorMessage = output.rawStopReason ? `Provider stopped with: ${output.rawStopReason}` : "An unknown error occurred";
+        throw new Error(errorMessage);
+      }
+      stream2.push({ type: "done", reason: output.stopReason, message: output });
+      stream2.end();
+    } catch (error) {
+      for (const block of output.content) {
+        if ("index" in block) {
+          delete block.index;
+        }
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatProviderError(normalizeProviderError(error));
+      stream2.push({ type: "error", reason: output.stopReason, error: output });
+      stream2.end();
+    }
+  })();
+  return stream2;
+};
+var streamSimple = (model, context, options) => {
+  const apiKey = options?.apiKey;
+  if (!apiKey) {
+    throw new Error(`No API key for provider: ${model.provider}`);
+  }
+  const base = buildBaseOptions(model, context, options, apiKey);
+  if (!options?.reasoning) {
+    return stream(model, context, { ...base, thinking: { enabled: false } });
+  }
+  const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+  const effort = clampedReasoning === "off" ? "high" : clampedReasoning;
+  const googleModel = model;
+  if (isGemini3ProModel(googleModel) || isGemini3FlashModel(googleModel) || isGemma4Model(googleModel)) {
+    return stream(model, context, {
+      ...base,
+      thinking: {
+        enabled: true,
+        level: getThinkingLevel(effort, googleModel)
+      }
+    });
+  }
+  return stream(model, context, {
+    ...base,
+    thinking: {
+      enabled: true,
+      budgetTokens: getGoogleBudget(googleModel, effort, options.thinkingBudgets)
+    }
+  });
+};
+function createClient(model, apiKey, optionsHeaders) {
+  const httpOptions = {};
+  if (model.baseUrl) {
+    httpOptions.baseUrl = model.baseUrl;
+    httpOptions.apiVersion = "";
+  }
+  const headers = providerHeadersToRecord({ ...model.headers, ...optionsHeaders });
+  if (headers) {
+    httpOptions.headers = headers;
+  }
+  return new GoogleGenAI({
+    apiKey,
+    httpOptions: Object.keys(httpOptions).length > 0 ? httpOptions : void 0
+  });
+}
+function buildParams(model, context, options = {}) {
+  const contents = convertMessages(model, context);
+  const generationConfig = {};
+  if (options.temperature !== void 0) {
+    generationConfig.temperature = options.temperature;
+  }
+  if (options.maxTokens !== void 0) {
+    generationConfig.maxOutputTokens = options.maxTokens;
+  }
+  const supportsStrictMode = supportsGoogleStrictToolSampling(model.id);
+  const functionCallingMode = context.tools?.length ? resolveGoogleFunctionCallingMode(context.tools, options.toolChoice, supportsStrictMode) : void 0;
+  const config = {
+    ...Object.keys(generationConfig).length > 0 && generationConfig,
+    ...context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) },
+    ...context.tools && context.tools.length > 0 && {
+      tools: convertTools(context.tools, false, supportsStrictMode)
+    },
+    ...functionCallingMode !== void 0 && {
+      toolConfig: { functionCallingConfig: { mode: functionCallingMode } }
+    }
+  };
+  if (options.thinking?.enabled && model.reasoning) {
+    const thinkingConfig = { includeThoughts: true };
+    if (options.thinking.level !== void 0) {
+      thinkingConfig.thinkingLevel = options.thinking.level;
+    } else if (options.thinking.budgetTokens !== void 0) {
+      thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+    }
+    config.thinkingConfig = thinkingConfig;
+  } else if (model.reasoning && options.thinking && !options.thinking.enabled) {
+    config.thinkingConfig = getDisabledThinkingConfig(model);
+  }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    config.abortSignal = options.signal;
+  }
+  const params = {
+    model: model.id,
+    contents,
+    config
+  };
+  return params;
+}
+function isGemma4Model(model) {
+  return /gemma-?4/.test(model.id.toLowerCase());
+}
+function isGemini3ProModel(model) {
+  return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
+}
+function isGemini3FlashModel(model) {
+  const id = model.id.toLowerCase();
+  return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
+}
+function getDisabledThinkingConfig(model) {
+  if (isGemini3ProModel(model)) {
+    return { thinkingLevel: "LOW" };
+  }
+  if (isGemini3FlashModel(model)) {
+    return { thinkingLevel: "MINIMAL" };
+  }
+  if (isGemma4Model(model)) {
+    return { thinkingLevel: "MINIMAL" };
+  }
+  return { thinkingBudget: 0 };
+}
+function getThinkingLevel(effort, model) {
+  if (isGemini3ProModel(model)) {
+    switch (effort) {
+      case "minimal":
+      case "low":
+        return "LOW";
+      case "medium":
+      case "high":
+        return "HIGH";
+    }
+  }
+  if (isGemma4Model(model)) {
+    switch (effort) {
+      case "minimal":
+      case "low":
+        return "MINIMAL";
+      case "medium":
+      case "high":
+        return "HIGH";
+    }
+  }
+  switch (effort) {
+    case "minimal":
+      return "MINIMAL";
+    case "low":
+      return "LOW";
+    case "medium":
+      return "MEDIUM";
+    case "high":
+      return "HIGH";
+  }
+}
+function getGoogleBudget(model, effort, customBudgets) {
+  if (customBudgets?.[effort] !== void 0) {
+    return customBudgets[effort];
+  }
+  if (model.id.includes("2.5-pro")) {
+    const budgets = {
+      minimal: 128,
+      low: 2048,
+      medium: 8192,
+      high: 32768
+    };
+    return budgets[effort];
+  }
+  if (model.id.includes("2.5-flash-lite")) {
+    const budgets = {
+      minimal: 512,
+      low: 2048,
+      medium: 8192,
+      high: 24576
+    };
+    return budgets[effort];
+  }
+  if (model.id.includes("2.5-flash")) {
+    const budgets = {
+      minimal: 128,
+      low: 2048,
+      medium: 8192,
+      high: 24576
+    };
+    return budgets[effort];
+  }
+  return -1;
+}
+export {
+  stream,
+  streamSimple
+};