@goah/cli 0.13.0 → 0.13.2

package/dist/chunk-R6I3VKME.js

@@ -0,0 +1,132 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+
+// node_modules/goah-ledger-contract/dist/transcript.js
+var TRANSCRIPT_FORMAT_VERSION = 1;
+var TRANSCRIPT_MIN_READABLE_VERSION = 0;
+var TRANSCRIPT_TYPES = /* @__PURE__ */ new Set(["transcript.started", "request.prepared", "turn.started", "message.user", "message.assistant.delta", "message.assistant.completed", "tool.called", "tool.completed", "context.compacted", "turn.completed", "transcript.completed", "transcript.interrupted"]);
+function isTranscriptEvent(event) {
+  return TRANSCRIPT_TYPES.has(event.type);
+}
+var TranscriptFormatUnsupportedError = class extends Error {
+  foundVersion;
+  supportedVersion;
+  constructor(foundVersion, supportedVersion = TRANSCRIPT_FORMAT_VERSION) {
+    super(`transcript format ${foundVersion} is unsupported by this harness (supports ${supportedVersion}); upgrade the harness`);
+    this.foundVersion = foundVersion;
+    this.supportedVersion = supportedVersion;
+    this.name = "TranscriptFormatUnsupportedError";
+  }
+};
+var TranscriptEventUnsupportedError = class extends Error {
+  eventType;
+  constructor(eventType) {
+    super(`required transcript event is unknown to this harness: ${eventType}`);
+    this.eventType = eventType;
+    this.name = "TranscriptEventUnsupportedError";
+  }
+};
+var TranscriptCorruptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TranscriptCorruptionError";
+  }
+};
+function upgradeTranscriptEvents(source) {
+  assertContiguous(source);
+  const starts = source.filter((event) => event.type === "transcript.started");
+  if (starts.length === 0) {
+    if (source.some((event) => isTranscriptNamespace(event.type)))
+      throw new TranscriptCorruptionError("transcript events exist without transcript.started");
+    return [...source];
+  }
+  if (starts.length !== 1)
+    throw new TranscriptCorruptionError("turn transcript stream contains multiple transcript.started events");
+  const rawVersion = field(starts[0].data, "formatVersion");
+  let version = rawVersion === void 0 ? 0 : Number(rawVersion);
+  if (!Number.isSafeInteger(version) || version < TRANSCRIPT_MIN_READABLE_VERSION)
+    throw new TranscriptCorruptionError(`invalid transcript format version: ${String(rawVersion)}`);
+  if (version > TRANSCRIPT_FORMAT_VERSION)
+    throw new TranscriptFormatUnsupportedError(version);
+  let events = [...source];
+  while (version < TRANSCRIPT_FORMAT_VERSION) {
+    if (version === 0) {
+      events = events.map((event) => event.type === "transcript.started" ? { ...event, data: { ...event.data, formatVersion: 1 } } : event);
+      version = 1;
+    } else
+      throw new TranscriptFormatUnsupportedError(version);
+  }
+  for (const event of events) {
+    if (!isTranscriptEvent(event) && isTranscriptNamespace(event.type) && event.ignorable !== true)
+      throw new TranscriptEventUnsupportedError(event.type);
+  }
+  return events;
+}
+function replayTranscript(events) {
+  const upgraded = upgradeTranscriptEvents(events);
+  const messages = [];
+  const calls = /* @__PURE__ */ new Map();
+  let status = "running";
+  let lastRequest = null;
+  for (const event of upgraded) {
+    if (!isTranscriptEvent(event))
+      continue;
+    const data = event.data;
+    if (event.type === "message.user" || event.type === "message.assistant.completed")
+      messages.push(data.message);
+    else if (event.type === "tool.called") {
+      const call = { callId: String(data.callId), name: String(data.name), arguments: data.arguments ?? null };
+      calls.set(call.callId, call);
+    } else if (event.type === "tool.completed") {
+      const callId = String(data.callId);
+      calls.delete(callId);
+      messages.push({ id: String(data.messageId ?? `tool:${callId}`), role: "tool", toolCallId: callId, content: data.result ?? null });
+    } else if (event.type === "context.compacted") {
+      const replaced = new Set(Array.isArray(data.replacedMessageIds) ? data.replacedMessageIds.map(String) : []);
+      const kept = messages.filter((message) => !replaced.has(message.id));
+      messages.splice(0, messages.length, ...kept);
+      messages.unshift({ id: String(data.summaryMessageId), role: "user", content: String(data.summary) });
+    } else if (event.type === "request.prepared")
+      lastRequest = event.data;
+    else if (event.type === "transcript.completed")
+      status = "completed";
+    else if (event.type === "transcript.interrupted")
+      status = "interrupted";
+  }
+  return { messages, status, openToolCalls: [...calls.values()], lastRequest };
+}
+function interruptedTranscriptEvents(events, ts, actor) {
+  const replayed = replayTranscript(events);
+  if (replayed.status !== "running" || !events.some((event) => event.type === "transcript.started"))
+    return [];
+  const streamId = events[0].streamId;
+  const repairs = replayed.openToolCalls.map((call) => ({ streamId, ts, actor, type: "tool.completed", data: { callId: call.callId, messageId: `repair:${call.callId}`, result: { outcome: "unknown", synthetic: true, reason: "runner interrupted before a durable result" } } }));
+  repairs.push({ streamId, ts, actor, type: "transcript.interrupted", data: { reason: "runner interrupted" } });
+  return repairs;
+}
+function assertContiguous(events) {
+  let expected = events[0]?.streamSeq ?? 1;
+  for (const event of events) {
+    if (event.streamSeq !== expected)
+      throw new TranscriptCorruptionError(`turn transcript stream gap: expected ${expected}, got ${event.streamSeq}`);
+    expected += 1;
+  }
+}
+function isTranscriptNamespace(type) {
+  return ["transcript.", "request.", "turn.", "message.", "tool.", "context."].some((prefix) => type.startsWith(prefix));
+}
+function field(value, key) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value[key] : void 0;
+}
+
+export {
+  TRANSCRIPT_FORMAT_VERSION,
+  TRANSCRIPT_MIN_READABLE_VERSION,
+  isTranscriptEvent,
+  TranscriptFormatUnsupportedError,
+  TranscriptEventUnsupportedError,
+  TranscriptCorruptionError,
+  upgradeTranscriptEvents,
+  replayTranscript,
+  interruptedTranscriptEvents
+};

package/dist/chunk-TJON22J4.js

@@ -0,0 +1,87 @@
+import { createRequire as __goahCreateRequire } from "node:module";
+const require = __goahCreateRequire(import.meta.url);
+
+// node_modules/goah-ledger-contract/dist/execution.js
+function goalAutomaticTarget(agent, goalId) {
+  return { targetKind: "goal", agent, goalId, specialistRole: null };
+}
+function specialistAutomaticTarget(agent, role) {
+  return { targetKind: "specialist", agent, goalId: null, specialistRole: role };
+}
+function goalRoute(goalId) {
+  return { routeKind: "goal", goalId, specialistRole: null };
+}
+function humanInboxRoute() {
+  return { routeKind: "human_inbox", goalId: null, specialistRole: null };
+}
+function humanRequestRoute() {
+  return { routeKind: "human_request", goalId: null, specialistRole: null };
+}
+function specialistInboxRoute(role) {
+  return { routeKind: "specialist_inbox", goalId: null, specialistRole: role };
+}
+function noGoalCommitment() {
+  return { goalId: null, goalRevision: null };
+}
+function goalCommitment(goalId, goalRevision) {
+  return { goalId, goalRevision };
+}
+function normalizeAssistantText(text) {
+  return text.replace(/\r\n?/g, "\n").trim();
+}
+var wakeTransitions = { queued: ["claimed", "cancelled"], claimed: ["queued", "consumed", "cancelled"], consumed: [], cancelled: [] };
+var goalTransitions = { active: ["paused", "blocked", "complete"], paused: ["active", "complete"], blocked: ["active", "complete"], complete: [] };
+function assertWakeTransition(from, to) {
+  if (!wakeTransitions[from].includes(to))
+    throw new Error(`invalid wake transition: ${from} -> ${to}`);
+}
+function assertGoalTransition(from, to) {
+  if (from !== to && !goalTransitions[from].includes(to))
+    throw new Error(`invalid goal transition: ${from} -> ${to}`);
+}
+function assertHandoff(value) {
+  assertAgentHandoff(value);
+  if (!value.goalId.trim() || !Number.isInteger(value.goalRevision) || value.goalRevision < 0 || !Number.isInteger(value.recordRevision) || value.recordRevision < 1)
+    throw new Error("invalid Goal handoff");
+}
+function assertAgentHandoff(value) {
+  if (!["progress", "waiting", "blocked", "completion_proposed"].includes(value.outcome) || !Array.isArray(value.evidence) || value.evidence.length === 0)
+    throw new Error("invalid Agent handoff");
+}
+function assertTurnOutput(value) {
+  if (!Number.isInteger(value.validationAttemptId) || value.validationAttemptId <= 0 || typeof value.validationToken !== "string" || !value.validationToken.trim())
+    throw new Error("committed Turn requires an accepted Handoff validation attempt and token");
+  assertAgentHandoff(value.handoff);
+}
+function assertGoalSnapshot(value) {
+  if (!value.objective.trim() || !value.owner.trim())
+    throw new Error("goal objective and owner are required");
+  if (value.observationMethod !== null && !value.observationMethod.trim())
+    throw new Error("goal observation method cannot be blank");
+  if (value.verificationMethod !== null && !value.verificationMethod.trim())
+    throw new Error("goal verification method cannot be blank");
+  if (value.parentId !== null && value.observationMethod === null)
+    throw new Error("child goal observation method is required");
+  if (value.parentId !== null && value.verificationMethod === null)
+    throw new Error("child goal verification method is required");
+  if (!["active", "paused", "blocked", "complete"].includes(value.phase))
+    throw new Error(`invalid goal phase: ${value.phase}`);
+}
+
+export {
+  goalAutomaticTarget,
+  specialistAutomaticTarget,
+  goalRoute,
+  humanInboxRoute,
+  humanRequestRoute,
+  specialistInboxRoute,
+  noGoalCommitment,
+  goalCommitment,
+  normalizeAssistantText,
+  assertWakeTransition,
+  assertGoalTransition,
+  assertHandoff,
+  assertAgentHandoff,
+  assertTurnOutput,
+  assertGoalSnapshot
+};