@rowan-agent/agent 0.29.0 → 0.31.0

package/README.md

@@ -12,7 +12,7 @@ import {
   InMemoryStore,
   loadPhases,
   loadSkills,
-} from "@rowan-agent/agent";
+} from "@rowan-agent/agent/runtime";
 
 const skills = await loadSkills("./.rowan/skills");
 const phases = await loadPhases("./.rowan/phases");

package/dist/chunk-HL6TMTA5.js

@@ -0,0 +1,265 @@
+// src/utils.ts
+function createId(prefix) {
+  return `${prefix}_${crypto.randomUUID().slice(0, 8)}`;
+}
+function createTimestamp(date = /* @__PURE__ */ new Date()) {
+  const offset = date.getTimezoneOffset();
+  const local = new Date(date.getTime() - offset * 6e4);
+  const iso = local.toISOString().slice(0, -1);
+  const sign = offset <= 0 ? "+" : "-";
+  const abs = Math.abs(offset);
+  const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+  const mm = String(abs % 60).padStart(2, "0");
+  return `${iso}${sign}${hh}:${mm}`;
+}
+function combineSignals(signalA, signalB) {
+  if (!signalA && !signalB) return new AbortController().signal;
+  if (!signalA) return signalB;
+  if (!signalB) return signalA;
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([signalA, signalB]);
+  }
+  if (signalA.aborted) return signalA;
+  if (signalB.aborted) return signalB;
+  const controller = new AbortController();
+  const onAbort = (ev) => {
+    const target = ev.target;
+    controller.abort(target.reason);
+  };
+  signalA.addEventListener("abort", onAbort, { once: true });
+  signalB.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
+function withAbort(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    const error = signal.reason instanceof Error ? signal.reason : new DOMException(typeof signal.reason === "string" ? signal.reason : "Tool execution aborted.", "AbortError");
+    return Promise.reject(error);
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      const error = signal.reason instanceof Error ? signal.reason : new DOMException(typeof signal.reason === "string" ? signal.reason : "Tool execution aborted.", "AbortError");
+      reject(error);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (val) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(val);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
+
+// src/runtime/json.ts
+function isPlainObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function hasOnlyDataProperties(value) {
+  return Reflect.ownKeys(value).every((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return Boolean(descriptor && "value" in descriptor);
+  });
+}
+function visit(value, seen) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || seen.has(value)) return false;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getPrototypeOf(value) !== Array.prototype || !hasOnlyDataProperties(value)) return false;
+      if (Reflect.ownKeys(value).some((key) => key !== "length" && typeof key !== "string")) return false;
+      for (let index = 0; index < value.length; index += 1) {
+        if (!Object.prototype.hasOwnProperty.call(value, index) || !visit(value[index], seen)) return false;
+      }
+      return true;
+    }
+    if (!isPlainObject(value) || !hasOnlyDataProperties(value)) return false;
+    if (Reflect.ownKeys(value).some((key) => typeof key !== "string")) return false;
+    if (Object.prototype.hasOwnProperty.call(value, "toJSON")) return false;
+    return Object.keys(value).every((key) => visit(value[key], seen));
+  } finally {
+    seen.delete(value);
+  }
+}
+function isJsonValue(value) {
+  return visit(value, /* @__PURE__ */ new Set());
+}
+function assertJsonValue(value, argument = "value") {
+  if (!isJsonValue(value)) throw new TypeError(`${argument} must be JSON-safe`);
+}
+function canonicalJson(value) {
+  assertJsonValue(value);
+  const encode = (candidate) => {
+    if (candidate === null || typeof candidate !== "object") return JSON.stringify(candidate);
+    if (Array.isArray(candidate)) return `[${candidate.map(encode).join(",")}]`;
+    const object = candidate;
+    return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${encode(object[key])}`).join(",")}}`;
+  };
+  return encode(value);
+}
+function utf8ByteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function assertUtf8ByteLimit(value, limit, argument = "value") {
+  if (utf8ByteLength(value) > limit) throw new RangeError(`${argument} exceeds ${limit} UTF-8 bytes`);
+}
+
+// src/harness/phases/interactions.ts
+var RunInteractionCancelledError = class extends Error {
+  code = "run_interaction_cancelled";
+  constructor(message = "Run interaction work was cancelled.") {
+    super(message);
+    this.name = "RunInteractionCancelledError";
+  }
+};
+var RunInteractionBoundary = class extends Error {
+  constructor(state, interactions) {
+    super("Run interactions require host input.");
+    this.state = state;
+    this.interactions = interactions;
+    this.name = "RunInteractionBoundary";
+  }
+  state;
+  interactions;
+};
+function createRunInteractionDriver(state, phase, signal) {
+  const stored = state.runInteractions ?? state.phaseInteractions;
+  const requests = new Map(
+    stored?.requests.map((request) => [request.id, { ...request }]) ?? []
+  );
+  const answers = new Map(Object.entries(stored?.answers ?? {}));
+  const usedRequestIds = /* @__PURE__ */ new Set();
+  let checkpoint = stored?.checkpoint;
+  const snapshot = () => ({
+    requests: [...requests.values()].map((request) => ({
+      ...request,
+      status: answers.has(request.id) ? "answered" : request.status
+    })),
+    answers: Object.fromEntries(answers),
+    ...checkpoint === void 0 ? {} : { checkpoint }
+  });
+  const sync = () => {
+    state.runInteractions = snapshot();
+  };
+  const assertActive = () => {
+    if (signal?.aborted) throw new RunInteractionCancelledError();
+  };
+  const matchingStoredRequest = (input) => {
+    const fingerprint = interactionFingerprint(input);
+    return [...requests.values()].find((request) => !usedRequestIds.has(request.id) && (answers.has(request.id) || request.status === "pending") && request.toolCallId === input.toolCallId && interactionFingerprint(request) === fingerprint);
+  };
+  return {
+    signal: signal ?? new AbortController().signal,
+    request(input) {
+      assertActive();
+      if (input.id !== void 0 && input.id.trim().length === 0) {
+        throw new TypeError("Run interaction id must be non-empty.");
+      }
+      if (input.prompt.trim().length === 0) {
+        throw new TypeError("Run interaction prompt must be non-empty.");
+      }
+      if (!RUN_INTERACTION_KINDS.includes(input.kind)) {
+        throw new TypeError(`Unsupported Run interaction kind: ${String(input.kind)}.`);
+      }
+      if (input.payload !== void 0) assertJsonValue(input.payload, "Run interaction payload");
+      const matched = input.id === void 0 ? matchingStoredRequest(input) : void 0;
+      const id = input.id ?? matched?.id ?? createId("interaction");
+      const existing = requests.get(id);
+      if (existing) {
+        if (interactionFingerprint(existing) !== interactionFingerprint(input)) {
+          throw new Error(`Run interaction ${id} was requested with different metadata.`);
+        }
+        usedRequestIds.add(id);
+        return {
+          ...existing,
+          status: answers.has(id) ? "answered" : existing.status
+        };
+      }
+      const request = {
+        id,
+        phase,
+        kind: input.kind,
+        prompt: input.prompt,
+        ...input.payload === void 0 ? {} : { payload: input.payload },
+        ...input.toolCallId === void 0 ? {} : { toolCallId: input.toolCallId },
+        ...input.result === void 0 ? {} : { result: input.result },
+        createdAt: createTimestamp(),
+        status: "pending"
+      };
+      requests.set(id, request);
+      usedRequestIds.add(id);
+      sync();
+      return request;
+    },
+    pending() {
+      return [...requests.values()].filter((request) => request.status === "pending" && !answers.has(request.id)).map((request) => ({ ...request, status: "pending" }));
+    },
+    answers() {
+      return new Map(answers);
+    },
+    checkpoint() {
+      return checkpoint;
+    },
+    clearCheckpoint() {
+      checkpoint = void 0;
+      sync();
+    },
+    answer(id, value) {
+      answers.set(id, value);
+      const req = requests.get(id);
+      if (req) {
+        requests.set(id, { ...req, status: "answered", answer: value });
+      }
+      sync();
+    },
+    clearAnswer(id) {
+      answers.delete(id);
+      requests.delete(id);
+      sync();
+    },
+    suspend(input = {}) {
+      assertActive();
+      const pending = this.pending();
+      if (pending.length === 0) throw new Error("Cannot suspend without pending Run interactions.");
+      if (input.checkpoint !== void 0) checkpoint = input.checkpoint;
+      state.status = "suspended";
+      sync();
+      throw new RunInteractionBoundary(state, pending);
+    }
+  };
+}
+var RUN_INTERACTION_KINDS = [
+  "user_input",
+  "permission",
+  "elicitation",
+  "confirmation"
+];
+function interactionFingerprint(value) {
+  return canonicalJson({
+    kind: value.kind,
+    prompt: value.prompt,
+    payload: value.payload ?? null
+  });
+}
+
+export {
+  createId,
+  createTimestamp,
+  combineSignals,
+  withAbort,
+  isJsonValue,
+  assertJsonValue,
+  canonicalJson,
+  assertUtf8ByteLimit,
+  RunInteractionCancelledError,
+  RunInteractionBoundary,
+  createRunInteractionDriver
+};