@unoverse-platform/studio 0.1.115 → 0.1.116

package/vendor/base/src/manifests/runtime/tools/toolloop.ts

@@ -32,8 +32,11 @@ import { makeUsageCollector } from "../usage.js";
 export interface ToolBridge {
   /** Core tools from the provider's getSchema, as { name, description, parameters }. */
   discover(): Promise<any[]>;
-  /** Execute one call; returns the raw result content. */
-  call(name: string, args: any): Promise<string>;
+  /**
+   * Execute one call; returns the raw result content. `onStatus` hears what a called TASK is
+   * doing each time its status changes (docs/mcp/MCP_TASKS.md § 5, "what reaches the model").
+   */
+  call(name: string, args: any, hooks?: { onStatus?: (statusMessage: string) => void }): Promise<string>;
   /**
    * Absorb one tool reply: unlock + shell-open any apps it discovered, and hand back the
    * MODEL-FACING form of it plus any tools to register.
@@ -92,7 +95,7 @@ export function recordToolTrace(
    * on the same timeline but is not a tool the model chose, so it is told apart by a stated
    * kind rather than by the viewer sniffing its name.
    */
-  kind: "tool" | "skill" | "task" = "tool",
+  kind: "tool" | "skill" | "task" | "turn" = "tool",
 ): void {
   recordCall({ executionId: (ctx as any)?.scope?.executionId, parentNodeId: (ctx as any)?.scope?.nodeId, toolName, args, result, startTime, success, kind, who: node.type });
 }
@@ -111,7 +114,7 @@ export function recordCall(call: {
   result: unknown;
   startTime: number;
   success: boolean;
-  kind?: "tool" | "skill" | "task";
+  kind?: "tool" | "skill" | "task" | "turn";
   who: string;
 }): void {
   const { executionId, parentNodeId, toolName, args, result, startTime, success, kind = "tool" } = call;
@@ -245,8 +248,8 @@ export async function runToolLoop(
    *  written, or the held set would keep a skill the conversation has walked away from. */
   let skillsChanged = false;
 
-  // Token usage across ALL turns of this run — each turn is its own model call with its
-  // own usage block; the collector sums them and posts once when the loop settles.
+  // Token usage, posted after EACH turn (each turn is its own model call with its own usage
+  // block), so a run's spend is on record while it runs, and once more when the loop settles.
   const usage = makeUsageCollector(node, ctx);
 
   for (turn = 1; turn <= maxTurns; turn++) {
@@ -275,6 +278,9 @@ export async function runToolLoop(
     // would send each result twice — once as a message and once in a field the vendor ignores.
     if (results && !te.transcript) extra[te.resultsInto ?? "input"] = results;
 
+    // WHEN THE TURN STARTED, for its own row on the timeline (below): without it the gap between
+    // two rounds of tool calls could not be told apart into model time and everything else.
+    const turnStart = Date.now();
     const res = await sendRequest(node, withExtra(modelCall, extra), scoped, `${node.type} (turn ${turn})`);
 
     // Two readers of one stream: the events table decides what leaves the node, and the
@@ -291,6 +297,12 @@ export async function runToolLoop(
      * Chat Completions), and accumulated because it arrives a token at a time.
      */
     let spoken = "";
+    /**
+     * The assistant's OWN REASONING this turn, for a vendor that keeps it only when it is sent back
+     * (GLM's preserved thinking). Without it the model rebuilds its whole plan every turn. Read and
+     * accumulated exactly as `spoken` is; the manifest says where it arrives and where it goes back.
+     */
+    let thought = "";
     await readSse(res, modelCall.terminator, async (payload) => {
       await assertOk(node, modelCall, payload, `${node.type} (turn ${turn})`);
       usage.see(payload);
@@ -299,6 +311,10 @@ export async function runToolLoop(
         const piece = await evaluate(te.transcript.text, { response: payload });
         if (piece) spoken += String(piece);
       }
+      if (te.transcript?.thinking) {
+        const piece = await evaluate(te.transcript.thinking, { response: payload });
+        if (piece) thought += String(piece);
+      }
       // `match` is OPTIONAL. It selects by event TYPE, which only works for a vendor whose SSE
       // events carry one — the Responses API does. A Chat Completions chunk has no `type` at all, so
       // with no match declared every payload is considered and `when` does the filtering.
@@ -306,6 +322,7 @@ export async function runToolLoop(
       if (te.continuity && payload.type === te.continuity.match) chainPayload = payload;
     });
     if (chainPayload) chainId = String(await evaluate(te.continuity.from, { response: chainPayload }));
+    usage.save();
 
     // THE TURN IS OVER, SO NOTHING MORE IS COMING TO CARRY A THROTTLE OUT.
     //
@@ -321,6 +338,9 @@ export async function runToolLoop(
     emitter.flush();
 
     const calls = await readCalls(te, raw);
+    // EACH MODEL TURN ON THE TIMELINE, beside the calls it asked for: how long the model took,
+    // what it asked for and how much it wrote. Recorded once the turn has streamed in full.
+    recordCall({ executionId: (ctx as any)?.scope?.executionId, parentNodeId: (ctx as any)?.scope?.nodeId, toolName: `turn ${turn}`, args: { toolsOffered: live.length }, result: { asked: calls.map((c) => c.name), wroteChars: spoken.length }, startTime: turnStart, success: true, kind: "turn", who: node.type });
 
     // Answered rather than called. Done.
     if (!calls.length) break;
@@ -337,6 +357,8 @@ export async function runToolLoop(
     const absorbed: string[] = [];
     let stuck = false;
 
+    // Which calls run: every one before the first repeated too often, in the order asked.
+    const toRun: { call: (typeof calls)[number]; args: any }[] = [];
     for (const call of calls) {
       const signature = `${call.name}:${call.arguments}`;
       const count = (seen.get(signature) ?? 0) + 1;
@@ -346,25 +368,38 @@ export async function runToolLoop(
         stuck = true;
         break;
       }
-
       const args = JSON.parse(call.arguments || "{}");
       narrate({ kind: "toolCall", toolName: call.name, args });
+      toRun.push({ call, args });
+    }
 
-      let content: string;
-      /**
-       * THE TIMELINE BAR is the TOOL's to record, never the loop's (owner, 2026-10-01;
-       * packages/docs/nodes/mcp-services.md, "Who records a call"). Every tool records its
-       * own call wherever it runs (a node's method, a row's function, a platform tool), with
-       * `success` false on a failure, so a call reads the same from an Agent, a voice session
-       * or an outside host. The bar once vanished the day `openai` migrated, because it lived
-       * in each Agent family; it lives with the tool now.
-       */
-      try {
-        content = await bridge.call(call.name, args);
-      } catch (err: any) {
-        // A failed tool is information for the model, not a crash: it can try another.
-        content = JSON.stringify({ error: err?.message ?? String(err) });
-      }
+    /**
+     * THE CALLS OF ONE TURN RUN TOGETHER (UNO-190; docs/mcp/MCP_TASKS.md § 5, Orchestrated).
+     * A model that asks for several tools at once wants them side by side: twelve searches
+     * fanned out as tasks take as long as the slowest, not the sum. Everything after the call
+     * (recording, absorbing, skills in force, minted tools) still goes in the order asked.
+     *
+     * THE TIMELINE BAR is the TOOL's to record, never the loop's (owner, 2026-10-01;
+     * packages/docs/nodes/mcp-services.md, "Who records a call"). Every tool records its
+     * own call wherever it runs (a node's method, a row's function, a platform tool), with
+     * `success` false on a failure, so a call reads the same from an Agent, a voice session
+     * or an outside host. The bar once vanished the day `openai` migrated, because it lived
+     * in each Agent family; it lives with the tool now.
+     */
+    const contents = await Promise.all(
+      toRun.map(({ call, args }) =>
+        Promise.resolve()
+          // A TASK THAT RUNS FOR MINUTES SAYS WHAT IT IS DOING: each new status is narrated,
+          // so the caller (a person, a voice) hears progress before the result arrives.
+          .then(() => bridge.call(call.name, args, { onStatus: (status) => narrate({ kind: "taskStatus", toolName: call.name, args, status }) }))
+          // A failed tool is information for the model, not a crash: it can try another.
+          .catch((err: any) => JSON.stringify({ error: err?.message ?? String(err) })),
+      ),
+    );
+
+    for (let i = 0; i < toRun.length; i++) {
+      const { call, args } = toRun[i];
+      const content = contents[i];
       exchanges.push({ name: call.name, resultContent: content });
       // The RESULT, and only now that it exists. It is never in the HTTP stream: our loop
       // produced it, which is why it cannot be a `from: response` row. PARSED for the
@@ -432,7 +467,7 @@ export async function runToolLoop(
      * vendor's message shape — `te.result` produced them — so they go in as they are.
      */
     if (te.transcript) {
-      if (te.transcript.assistant) transcript.push(await evaluate(te.transcript.assistant, { calls, text: spoken }));
+      if (te.transcript.assistant) transcript.push(await evaluate(te.transcript.assistant, { calls, text: spoken, thinking: thought }));
       transcript.push(...results);
     }
   }

package/vendor/base/src/manifests/runtime/usage.ts

@@ -15,8 +15,8 @@
  * Sniffing those three is a wire-format rule, not a per-node rule — no manifest changes.
  *
  * A run may hold SEVERAL model calls (the tool loop's turns), each with its own usage
- * block; the collector SUMS numeric fields across them, which is what "this execution
- * cost N tokens" means. Fire-and-forget on save, same contract as the MCP trace:
+ * block; the collector SUMS numeric fields across what it saw since its last save, and the
+ * rows for one execution add up to what it cost. Fire-and-forget on save, same contract as the MCP trace:
  * observability must never slow a run or fail it.
  */
 import type { ComposedNode } from "../compose.js";
@@ -38,7 +38,12 @@ export interface UsageCollector {
    * the length. A vendor that reports running totals (GPT-Live) would otherwise be summed.
    */
   set(field: string, value: number): void;
-  /** Post the summed usage to the engine. No usage seen, or no execution scope → no-op. */
+  /**
+   * Post what was seen SINCE THE LAST SAVE to the engine, then start again from nothing. Called
+   * after each turn of a tool loop, so spend is on record while the run is still going: a budget
+   * read mid-run (an Agent's, AGENTS.md § 9) saw nothing until the loop settled. Nothing new, or no
+   * execution scope → no-op.
+   */
   save(): void;
 }
 
@@ -61,7 +66,7 @@ function addInto(totals: Record<string, any>, block: Record<string, unknown>): v
 }
 
 export function makeUsageCollector(node: ComposedNode, ctx: RunContext): UsageCollector {
-  const totals: Record<string, number | Record<string, number>> = {};
+  let totals: Record<string, number | Record<string, number>> = {};
   let seen = false;
   let model: string | undefined;
 
@@ -80,6 +85,9 @@ export function makeUsageCollector(node: ComposedNode, ctx: RunContext): UsageCo
     },
     save() {
       if (!seen) return;
+      const spent = totals;
+      totals = {};
+      seen = false;
       const { workflowId, executionId, nodeId } = ctx.scope ?? {};
       // Node-test / headless: no execution to attach to (same rule as the MCP trace).
       if (!workflowId || !executionId || !nodeId) return;
@@ -89,7 +97,7 @@ export function makeUsageCollector(node: ComposedNode, ctx: RunContext): UsageCo
         nodeId,
         nodeType: node.type,
         model: model ?? (ctx.config as any)?.model ?? "unknown",
-        usage: totals,
+        usage: spent,
         timestamp: new Date().toISOString(),
       });
     },

package/vendor/base/src/platform/agentBudget.ts

@@ -0,0 +1,65 @@
+/**
+ * AN AGENT'S BUDGET (docs/architecture/signal/AGENTS.md § 9, § 9a; UNO-222).
+ *
+ * Counted, not trusted: what an Agent spent is the platform's own usage rows (`token_usage`) for
+ * everything run as the Agent (its own thinking and every task it called), priced by the one table
+ * (`tokenCost.ts`). Checked BEFORE every model call and every task, never after:
+ *
+ *   under 80% of a limit   go on
+ *   80% or more            go on, its owner is told once
+ *   100%                   start nothing new
+ *
+ * Pure: the rows and the limits come in.
+ */
+import { parseTokenUsage, calculateTokenCost } from "./tokenCost.js";
+
+/** "20 USD", "20", "$20" → 20. Null when it is not an amount in US dollars. */
+export function dollars(amount: string | undefined): number | null {
+  if (!amount) return null;
+  const m = /^\s*\$?\s*(\d+(?:\.\d+)?)\s*(USD)?\s*$/i.exec(amount);
+  return m ? Number(m[1]) : null;
+}
+
+/** One usage row as the platform keeps it. */
+export interface UsageRow {
+  model: string | null;
+  usage: unknown;
+}
+
+/** What these rows cost, in US dollars. */
+export function spent(rows: UsageRow[]): number {
+  let total = 0;
+  for (const row of rows) {
+    if (!row.model) continue;
+    total += Number(calculateTokenCost(row.model, parseTokenUsage(row.model, row.usage)));
+  }
+  return Math.round(total * 10000) / 10000;
+}
+
+export interface BudgetLimits {
+  perDay?: string;
+  perRun?: string;
+}
+
+export type BudgetCheck =
+  | { go: true; near?: "day" | "run"; message?: string }
+  | { go: false; limit: "day" | "run" | "none"; message: string };
+
+/** May the Agent start one more model call or task? */
+export function checkBudget(limits: BudgetLimits, used: { today: number; run: number }): BudgetCheck {
+  const day = dollars(limits.perDay);
+  if (day === null) return { go: false, limit: "none", message: "No daily budget: an Agent with no budget.perDay never runs" };
+  const run = dollars(limits.perRun);
+  if (used.today >= day) return { go: false, limit: "day", message: `Today's budget is spent: $${used.today.toFixed(2)} of $${day.toFixed(2)}. Carries on tomorrow.` };
+  if (run !== null && used.run >= run) return { go: false, limit: "run", message: `This run's budget is spent: $${used.run.toFixed(2)} of $${run.toFixed(2)}.` };
+  if (used.today >= day * 0.8) return { go: true, near: "day", message: `$${used.today.toFixed(2)} of today's $${day.toFixed(2)} spent` };
+  if (run !== null && used.run >= run * 0.8) return { go: true, near: "run", message: `$${used.run.toFixed(2)} of this run's $${run.toFixed(2)} spent` };
+  return { go: true };
+}
+
+/** Midnight today in the environment's own time zone, where an Agent's day starts. */
+export function startOfToday(now: Date = new Date()): Date {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}

package/vendor/base/src/platform/agentCalendar.ts

@@ -0,0 +1,87 @@
+/**
+ * AN AGENT'S DAY IS ITS CALENDAR (docs/architecture/signal/AGENTS.md § 5; UNO-207).
+ *
+ * A person drops slots into the Agent's calendar: the title names the slot, the description is
+ * what to do. Every `checkIn` the calendar is read; a slot that started since the last look, or is
+ * under way now, wakes the Agent, once, with the slot as its instruction: its work is a task from the
+ * moment it is on the calendar, never something to wait for. These are the rules; the engine's check-in
+ * (`engine/src/agentKeys/checkIn.ts`) reads the calendar and wakes it.
+ *
+ * Only people in its org give it work (§ 7b): a slot made by the mailbox itself, or by someone at
+ * the same company domain. A public mail domain (gmail.com and the like) is nobody's company, so
+ * there only the mailbox's own slots count. An outside invitation is never an instruction.
+ *
+ * A slot names the Agent (owner, 2026-10-10: "start with Bob:"): its title begins with the Agent's
+ * name and a colon, "Bob: Morning sweep". Every other event in the calendar is a person's own
+ * meeting and never wakes it, which matters while it reads a person's calendar rather than its own.
+ */
+
+/** The fields of an event these rules read. */
+export interface SlotEvent {
+  id: string;
+  title: string;
+  description: string;
+  start: string;
+  /** When it ends; empty for none. A slot under way still wakes an Agent that has not worked it. */
+  end?: string | null;
+  organizer: { address: string } | null;
+  creator: { address: string } | null;
+}
+
+/** How often its calendar is read when its file says nothing. */
+export const DEFAULT_CHECK_IN_MS = 15 * 60_000;
+
+/** "15m", "1h", "30s" → milliseconds; anything else, the default. Never under a minute. */
+export function checkInEvery(checkIn: string | undefined): number {
+  const m = /^\s*(\d+)\s*(s|m|h)\s*$/i.exec(checkIn ?? "");
+  if (!m) return DEFAULT_CHECK_IN_MS;
+  const ms = Number(m[1]) * { s: 1000, m: 60_000, h: 3_600_000 }[m[2].toLowerCase() as "s" | "m" | "h"];
+  return Math.max(ms, 60_000);
+}
+
+const PUBLIC_DOMAINS = new Set(["gmail.com", "googlemail.com", "outlook.com", "hotmail.com", "live.com", "msn.com", "yahoo.com", "icloud.com", "me.com", "proton.me", "protonmail.com", "aol.com"]);
+const domainOf = (address: string) => address.slice(address.lastIndexOf("@") + 1).toLowerCase();
+
+/** Was this slot made by someone in the Agent's org? */
+export function fromOrg(event: SlotEvent, mailbox: string): boolean {
+  const maker = (event.creator ?? event.organizer)?.address?.toLowerCase();
+  const own = mailbox.trim().toLowerCase();
+  if (!maker) return false;
+  if (maker === own) return true;
+  const domain = domainOf(own);
+  return !PUBLIC_DOMAINS.has(domain) && domainOf(maker) === domain;
+}
+
+/** "Bob: Morning sweep" for Bob → "Morning sweep"; null when the slot is not addressed to it. */
+export function addressedTo(title: string, agentName: string): string | null {
+  const name = agentName.trim().toLowerCase();
+  const t = title.trim();
+  if (!name || t.slice(0, name.length + 1).toLowerCase() !== `${name}:`) return null;
+  return t.slice(name.length + 1).trim();
+}
+
+/** The slots to work now, earliest first: started after `since` and by `now`, or started earlier
+ *  and still under way. Whether one was already worked is the run record's (`slotKey`). */
+export function slotsDue<T extends SlotEvent>(events: T[], since: Date, now: Date): T[] {
+  return events
+    .filter((e) => {
+      const at = Date.parse(e.start);
+      if (at > now.getTime()) return false;
+      if (at > since.getTime()) return true;
+      const end = e.end ? Date.parse(e.end) : NaN;
+      return end > now.getTime();
+    })
+    .sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
+}
+
+/** One slot, once: a recurring slot's occurrences differ by start. What its run is recorded as. */
+export function slotKey(event: SlotEvent): string {
+  return `calendar:${event.id}@${event.start}`;
+}
+
+/** What the Agent is told when a slot starts. */
+export function slotInstruction(event: SlotEvent, agentName: string): string {
+  const what = event.description.trim();
+  const title = addressedTo(event.title, agentName) || event.title.trim() || "(untitled)";
+  return `Your calendar: "${title}" has started.${what ? `\n\n${what}` : "\n\nIt has no description: do your job, as your skills say."}`;
+}

package/vendor/base/src/platform/taskChanged.ts

@@ -0,0 +1,25 @@
+/**
+ * "A TASK CHANGED" (docs/mcp/MCP_TASKS.md § 5a, S3; step 6). Whatever writes a task's row says
+ * so here, once, after the write: the engine when a run starts and ends, the server when a step
+ * is saved or a node starts or stops asking. It lives in base because both write rows, in one
+ * process; a client following that task (`notifications/tasks`, server/taskListen.ts) is sent the
+ * whole task again. Nothing else lives here.
+ */
+const listeners = new Set<(taskId: string) => void>();
+
+/** Listen for changed tasks. Returns the way to stop listening. */
+export function onTaskChanged(listener: (taskId: string) => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** Say a task's row changed. A listener that fails never stops the others. */
+export function taskChanged(taskId: string): void {
+  for (const listener of listeners) {
+    try {
+      listener(taskId);
+    } catch {
+      /* one entry's failure is its own */
+    }
+  }
+}