@anvia/core 1.1.2 → 1.2.1

package/dist/chunk-SIYZDPVH.js

@@ -0,0 +1,613 @@
+import {
+  TEAM_INSTRUCTIONS,
+  teamTools
+} from "./chunk-B47EXUHL.js";
+import {
+  TeamChanges,
+  TeamSlots,
+  abortable
+} from "./chunk-PIMD4DYG.js";
+import {
+  agentMessageInput,
+  memberSummary,
+  steeringMessages
+} from "./chunk-T4KS577P.js";
+import {
+  AgentTeamInteractionError,
+  AgentTeamLimitError
+} from "./chunk-ENZ2XX27.js";
+import {
+  createResolvedAgent,
+  getResolvedAgentOptions
+} from "./chunk-T4IAJJUU.js";
+import {
+  AgentRun
+} from "./chunk-RT5LUEO3.js";
+import {
+  withInternalAgentRunOptions
+} from "./chunk-KITX3HDN.js";
+import {
+  assertAgentInteractionResponse,
+  parseAgentInteractionResponse
+} from "./chunk-LBYJPMHC.js";
+import {
+  composeAgentLifecycle,
+  lifecycleSnapshot
+} from "./chunk-KFAVEL5F.js";
+import {
+  isStreamingCompletionModel
+} from "./chunk-BDKFFFVX.js";
+import {
+  Usage
+} from "./chunk-IDNL6IH4.js";
+import {
+  parseMessages
+} from "./chunk-BONQTXRQ.js";
+import {
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
+import {
+  AgentRunCancelledError,
+  AgentStreamClosedError
+} from "./chunk-WN6AVBO4.js";
+
+// src/internal/team-runtime/run.ts
+var TeamRun = class {
+  constructor(leader, policy, limits, options, streaming, emit) {
+    this.policy = policy;
+    this.limits = limits;
+    this.options = options;
+    this.streaming = streaming;
+    this.emit = emit;
+    this.slots = new TeamSlots(limits.maxConcurrentAgents);
+    this.leader = this.createMember(leader, leader.name ?? leader.id);
+    const messages = options.messages === void 0 ? steeringMessages({ prompt: options.prompt }) : parseMessages(options.messages);
+    const last = messages.at(-1);
+    if (last?.role !== "user")
+      throw new TypeError("Agent team input must end with a user message.");
+    this.leader.history = messages.slice(0, -1);
+    this.leader.inputs.push({
+      id: globalThis.crypto.randomUUID(),
+      messages: [last],
+      submitted: false
+    });
+    if (options.abortSignal !== void 0) {
+      const signal = options.abortSignal;
+      const abort = () => this.cancel("Agent team aborted.");
+      if (signal.aborted) abort();
+      else {
+        signal.addEventListener("abort", abort, { once: true });
+        this.removeAbortListener = () => signal.removeEventListener("abort", abort);
+      }
+    }
+  }
+  policy;
+  limits;
+  options;
+  streaming;
+  emit;
+  id = globalThis.crypto.randomUUID();
+  controller = new AbortController();
+  changes = new TeamChanges();
+  slots;
+  instances = /* @__PURE__ */ new Map();
+  leader;
+  closed = false;
+  started = false;
+  turns = 0;
+  fatal;
+  removeAbortListener;
+  async execute() {
+    if (this.started) throw new Error("Agent team execution has already started.");
+    this.started = true;
+    try {
+      this.assertOpen();
+      this.launch(this.leader);
+      while (true) {
+        this.assertOpen();
+        const version = this.changes.version;
+        if (this.leader.status === "failed" && this.leader.outcome?.type !== "blocked")
+          throw this.leader.error;
+        const outcome = this.leader.outcome;
+        if (outcome !== void 0 && (outcome.type === "blocked" || this.leader.status === "idle" && this.leader.task === void 0 && this.leader.inputs.length === 0 && !this.childrenBusy())) {
+          this.closed = true;
+          this.stopMembers();
+          await this.settleMembers();
+          const result = {
+            ...outcome,
+            teamRunId: this.id,
+            usage: [...this.instances.values()].reduce(
+              (usage, member) => Usage.add(usage, member.usage),
+              Usage.empty()
+            ),
+            members: [...this.instances.values()].filter((member) => member !== this.leader).map(memberSummary)
+          };
+          this.emit(result);
+          return result;
+        }
+        await this.changes.wait(version, this.controller.signal);
+      }
+    } catch (error) {
+      this.closed = true;
+      this.stopMembers();
+      await this.settleMembers();
+      throw this.fatal ?? error;
+    } finally {
+      this.removeAbortListener?.();
+    }
+  }
+  steer(input) {
+    this.assertOpen();
+    const entry = {
+      id: globalThis.crypto.randomUUID(),
+      messages: steeringMessages(input),
+      submitted: false
+    };
+    this.enqueue(this.leader, entry);
+    return { id: entry.id, status: "queued" };
+  }
+  cancel(reason = "Agent team cancelled.") {
+    if (this.closed || this.controller.signal.aborted) return;
+    this.fail(new AgentRunCancelledError([], reason));
+  }
+  spawn(parent, definition, prompt, name) {
+    this.assertOpen();
+    throwIfAborted(parent.controller.signal);
+    if (!this.policy.spawnTargets(parent).includes(definition))
+      throw new Error(`Agent "${parent.definition.id}" cannot spawn "${definition.id}".`);
+    if (parent.depth >= this.limits.maxDepth) throw new AgentTeamLimitError("maxDepth");
+    if (this.instances.size >= this.limits.maxAgentInstances)
+      throw new AgentTeamLimitError("maxAgentInstances");
+    const member = this.createMember(definition, name ?? definition.name ?? definition.id, parent);
+    member.inputs.push({
+      id: globalThis.crypto.randomUUID(),
+      messages: [{ role: "user", content: prompt }],
+      submitted: false
+    });
+    this.memberEvent(member, "agent_queued");
+    this.launch(member);
+    return { instanceId: member.instanceId, status: "queued" };
+  }
+  send(sender, input) {
+    this.assertOpen();
+    throwIfAborted(sender.controller.signal);
+    const recipient = this.recipient(sender, input.to);
+    if (recipient.status === "failed" || recipient.status === "cancelled") {
+      throw new Error(`Agent instance "${recipient.instanceId}" is ${recipient.status}.`);
+    }
+    return this.queueMessage(sender, recipient, input);
+  }
+  queueMessage(sender, recipient, input, notificationType = "message") {
+    const message = {
+      id: globalThis.crypto.randomUUID(),
+      teamRunId: this.id,
+      fromInstanceId: sender.instanceId,
+      toInstanceId: recipient.instanceId,
+      content: input.content,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...input.replyTo === void 0 ? {} : { replyTo: input.replyTo }
+    };
+    this.enqueue(recipient, agentMessageInput(message), notificationType);
+    return { messageId: message.id, status: "queued" };
+  }
+  visibleMembers(caller) {
+    return [...this.instances.values()].filter((member) => this.policy.canAccess(caller, member)).map((member) => ({
+      instanceId: member.instanceId,
+      agentId: member.agent.id,
+      name: member.name,
+      status: member.status,
+      depth: member.depth,
+      ...member.parentInstanceId === void 0 ? {} : { parentInstanceId: member.parentInstanceId }
+    }));
+  }
+  cancelMember(caller, instanceId, reason = "Cancelled by parent.") {
+    this.assertOpen();
+    throwIfAborted(caller.controller.signal);
+    const member = this.recipient(caller, instanceId);
+    if (member.parentInstanceId !== caller.instanceId)
+      throw new Error("Only a parent can cancel its child.");
+    if (member.status === "cancelled") return { instanceId, status: "cancelled" };
+    this.stopMember(member, reason);
+    this.stopDescendants(member, reason);
+    if (member.task === void 0) this.reportOutcome(member);
+    return { instanceId, status: "cancelled" };
+  }
+  async wait(member, instanceId, timeoutMs) {
+    this.assertOpen();
+    const target = instanceId === void 0 ? void 0 : this.recipient(member, instanceId);
+    const deadline = Date.now() + timeoutMs;
+    return this.yieldSlot(member, "waiting", async () => {
+      while (true) {
+        const version = this.changes.version;
+        const index = member.notifications.findIndex(
+          (notification) => target === void 0 || notification.from === target.instanceId
+        );
+        if (index !== -1) {
+          const notification = member.notifications.splice(index, 1)[0];
+          return {
+            reason: notification.type,
+            instanceId: notification.from,
+            messageId: notification.id
+          };
+        }
+        if (target !== void 0 && ["idle", "failed", "cancelled"].includes(target.status)) {
+          return { reason: "outcome", instanceId: target.instanceId, status: target.status };
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) return { reason: "timeout" };
+        await this.changes.wait(version, member.controller.signal, remaining);
+      }
+    });
+  }
+  createMember(agent, name, parent) {
+    const parentInstanceId = parent?.instanceId;
+    const member = {
+      instanceId: globalThis.crypto.randomUUID(),
+      agent,
+      definition: agent,
+      depth: parent === void 0 ? 0 : parent.depth + 1,
+      name,
+      ...parentInstanceId === void 0 ? {} : { parentInstanceId },
+      status: "queued",
+      history: [],
+      inputs: [],
+      receipts: /* @__PURE__ */ new Map(),
+      controller: new AbortController(),
+      usage: Usage.empty(),
+      notifications: []
+    };
+    const resolved = getResolvedAgentOptions(member.agent);
+    member.agent = createResolvedAgent({
+      ...resolved,
+      instructions: [
+        resolved.instructions,
+        TEAM_INSTRUCTIONS,
+        `Your instance ID is ${member.instanceId}. ${parentInstanceId === void 0 ? "You are the coordinator. Spawn tools create independent members; their outcomes are delivered automatically." : `Your parent instance is ${parentInstanceId}.`}`
+      ].filter(Boolean).join("\n\n"),
+      tools: [
+        ...resolved.tools ?? [],
+        ...teamTools(this, member, this.policy.spawnTargets(member))
+      ]
+    });
+    this.instances.set(member.instanceId, member);
+    return member;
+  }
+  recipient(sender, to) {
+    const id = to === "parent" ? sender.parentInstanceId : to;
+    const recipient = id === void 0 ? void 0 : this.instances.get(id);
+    if (recipient === void 0 || recipient === sender || !this.policy.canAccess(sender, recipient)) {
+      throw new Error(
+        `Agent instance "${to}" is not an accessible parent or child, or enabled sibling.`
+      );
+    }
+    return recipient;
+  }
+  enqueue(member, input, notificationType = "message") {
+    if (member.inputs.length >= 128)
+      throw new AgentTeamLimitError("pending messages per instance (128)");
+    member.inputs.push(input);
+    if (input.message !== void 0) {
+      this.emit({ type: "message_queued", ...this.identity(member), message: input.message });
+      member.notifications.push({
+        type: notificationType,
+        from: input.message.fromInstanceId,
+        id: input.id
+      });
+    }
+    this.submitInputs(member);
+    if (this.started && member.task === void 0) this.launch(member);
+    this.changes.notify();
+  }
+  submitInputs(member) {
+    if (member.activeRun === void 0) return;
+    for (const input of member.inputs) {
+      if (input.submitted) continue;
+      try {
+        const receipt = member.activeRun.steer({ messages: input.messages });
+        member.receipts.set(receipt.id, input);
+        input.submitted = true;
+      } catch (error) {
+        if (error instanceof AgentStreamClosedError) return;
+        throw error;
+      }
+    }
+  }
+  delivered(member, input) {
+    const index = member.inputs.indexOf(input);
+    if (index !== -1) member.inputs.splice(index, 1);
+    member.notifications = member.notifications.filter(
+      (notification) => notification.id !== input.id
+    );
+    if (input.message !== void 0)
+      this.emit({ type: "message_delivered", ...this.identity(member), message: input.message });
+  }
+  launch(member) {
+    if (member.task !== void 0 || this.closed || member.controller.signal.aborted) return;
+    member.status = "queued";
+    member.task = Promise.resolve().then(() => this.runMember(member)).catch((error) => {
+      member.error = error;
+      member.inputs.length = 0;
+      if (member.controller.signal.aborted) member.status = "cancelled";
+      else {
+        member.status = "failed";
+        this.memberEvent(member, "agent_failed");
+      }
+      this.stopDescendants(member, "Parent failed or was cancelled.");
+      if (!this.closed && !this.controller.signal.aborted && member !== this.leader) {
+        try {
+          this.reportOutcome(member);
+        } catch (reportError) {
+          this.fail(reportError);
+        }
+      }
+    }).finally(() => {
+      member.release?.();
+      member.release = void 0;
+      member.activeRun = void 0;
+      member.task = void 0;
+      if (member.status === "idle" && member.inputs.length > 0) this.launch(member);
+      this.changes.notify();
+    });
+    this.changes.notify();
+  }
+  async runMember(member) {
+    const signal = member.controller.signal;
+    member.release = await this.slots.acquire(signal);
+    let nextInput;
+    let firstInputs = [];
+    while (true) {
+      throwIfAborted(signal);
+      member.status = "running";
+      member.runId = globalThis.crypto.randomUUID();
+      if (nextInput === void 0) {
+        firstInputs = member.inputs.filter((input) => !input.submitted);
+        const incoming = firstInputs.flatMap((input) => input.messages);
+        if (incoming.length === 0) throw new Error("Agent team member has no input.");
+        nextInput = { messages: [...member.history, ...incoming] };
+        member.history.push(...incoming.slice(0, -1));
+        for (const input of firstInputs) input.submitted = true;
+      }
+      const streaming = this.streaming && member.agent.model.capabilities.streaming && isStreamingCompletionModel(member.agent.model);
+      const baseSettings = member === this.leader ? {
+        maxTurns: this.options.maxTurns,
+        retries: this.options.retries,
+        lifecycle: this.options.lifecycle,
+        guardrails: this.options.guardrails,
+        middlewares: this.options.middlewares,
+        trace: this.options.trace,
+        controls: this.options.controls
+      } : {};
+      const run = AgentRun.fromAgent(
+        member.agent,
+        withInternalAgentRunOptions(
+          {
+            ...baseSettings,
+            ...nextInput,
+            abortSignal: signal,
+            // Collaboration tools mutate one inbox/permit at a time; provider tools may still run independently across agents.
+            toolConcurrency: 1,
+            lifecycle: composeAgentLifecycle(baseSettings.lifecycle, {
+              onStepFinish: (event) => {
+                if (!streaming)
+                  this.agentEvent(member, {
+                    type: "turn_end",
+                    turn: event.step,
+                    response: lifecycleSnapshot(event.response)
+                  });
+              },
+              onError: (event) => {
+                member.usage = Usage.add(member.usage, event.usage);
+              }
+            })
+          },
+          {
+            runId: member.runId,
+            hook: {
+              onCompletionCall: () => {
+                this.assertOpen();
+                if (this.turns >= this.limits.maxTotalTurns) {
+                  const error = new AgentTeamLimitError("maxTotalTurns");
+                  this.fail(error);
+                  throw error;
+                }
+                this.turns += 1;
+                for (const input of firstInputs) this.delivered(member, input);
+                firstInputs = [];
+              }
+            },
+            beforeFinish: () => this.waitForChildren(member),
+            onSteeringApplied: (id) => {
+              const input = member.receipts.get(id);
+              if (input !== void 0) {
+                member.receipts.delete(id);
+                this.delivered(member, input);
+              }
+            }
+          }
+        )
+      );
+      member.activeRun = run;
+      this.submitInputs(member);
+      this.memberEvent(member, "agent_started");
+      const outcome = await abortable(this.consumeRun(member, run, streaming), signal);
+      member.activeRun = void 0;
+      member.usage = Usage.add(member.usage, outcome.usage);
+      member.history.push(...outcome.messages);
+      if (outcome.type === "interaction") {
+        const resolver = this.options.resolveInteraction;
+        this.emit({
+          type: "interaction",
+          ...this.identity(member),
+          interaction: lifecycleSnapshot(outcome.interaction)
+        });
+        if (resolver === void 0) {
+          const error = new AgentTeamInteractionError(member.instanceId);
+          this.fail(error);
+          throw error;
+        }
+        try {
+          const response = await this.yieldSlot(
+            member,
+            "awaiting_interaction",
+            () => abortable(
+              Promise.resolve().then(
+                () => resolver({
+                  teamRunId: this.id,
+                  instanceId: member.instanceId,
+                  runId: outcome.runId,
+                  interaction: lifecycleSnapshot(outcome.interaction),
+                  abortSignal: signal
+                })
+              ),
+              signal
+            )
+          );
+          const parsed = parseAgentInteractionResponse(response);
+          assertAgentInteractionResponse(outcome.interaction, parsed);
+          nextInput = { continuation: outcome.continuation, response: parsed };
+        } catch (cause) {
+          if (signal.aborted) throw cause;
+          const error = new AgentTeamInteractionError(member.instanceId, { cause });
+          this.fail(error);
+          throw error;
+        }
+        continue;
+      }
+      member.outcome = outcome;
+      member.status = outcome.type === "blocked" ? "failed" : "idle";
+      if (outcome.type === "blocked") {
+        member.inputs.length = 0;
+        this.stopDescendants(member, "Parent was blocked.");
+      }
+      this.memberEvent(member, outcome.type === "blocked" ? "agent_failed" : "agent_idle");
+      if (member !== this.leader) this.reportOutcome(member);
+      return;
+    }
+  }
+  async consumeRun(member, run, streaming) {
+    if (!streaming) {
+      const outcome = await run.generate();
+      if (outcome.type === "response")
+        this.agentEvent(member, { type: "text_delta", turn: 0, delta: outcome.text });
+      this.agentEvent(member, outcome);
+      return outcome;
+    }
+    for await (const event of run.events()) {
+      this.agentEvent(member, event);
+      if (event.type === "error") throw event.error;
+      if (event.type === "response" || event.type === "blocked" || event.type === "interaction")
+        return event;
+    }
+    throw new Error("Agent team member stream ended without an outcome.");
+  }
+  reportOutcome(member) {
+    const parent = this.instances.get(member.parentInstanceId);
+    if (parent === void 0 || parent.status === "failed" || parent.status === "cancelled") return;
+    const content = JSON.stringify({
+      type: "agent-outcome",
+      instanceId: member.instanceId,
+      status: member.status,
+      ...member.outcome?.type === "response" ? { output: member.outcome.output } : {},
+      ...member.outcome?.type === "blocked" ? { reason: member.outcome.reason } : {},
+      ...member.error === void 0 ? {} : { error: member.error instanceof Error ? member.error.message : String(member.error) }
+    });
+    this.queueMessage(member, parent, { content }, "outcome");
+  }
+  async waitForChildren(member) {
+    if (!this.childrenBusy(member) || member.inputs.length > 0) return;
+    await this.yieldSlot(member, "waiting", async () => {
+      while (this.childrenBusy(member) && member.inputs.length === 0) {
+        const version = this.changes.version;
+        await this.changes.wait(version, member.controller.signal);
+      }
+    });
+  }
+  // Without a parent, final team settlement checks all descendants, including revived assignments.
+  childrenBusy(parent) {
+    return [...this.instances.values()].some(
+      (member) => member !== this.leader && (parent === void 0 || member.parentInstanceId === parent.instanceId) && (["queued", "running", "waiting", "awaiting_interaction"].includes(member.status) || member.inputs.length > 0)
+    );
+  }
+  async yieldSlot(member, status, work) {
+    member.release?.();
+    member.release = void 0;
+    member.status = status;
+    this.memberEvent(member, "agent_waiting");
+    this.changes.notify();
+    try {
+      return await work();
+    } finally {
+      if (!member.controller.signal.aborted && !this.closed) {
+        member.release = await this.slots.acquire(member.controller.signal);
+        member.status = "running";
+        this.changes.notify();
+      }
+    }
+  }
+  identity(member) {
+    return {
+      teamRunId: this.id,
+      instanceId: member.instanceId,
+      ...member.runId === void 0 ? {} : { runId: member.runId }
+    };
+  }
+  memberEvent(member, type) {
+    this.emit({ type, ...this.identity(member), member: memberSummary(member) });
+  }
+  agentEvent(member, event) {
+    if (this.closed || member.controller.signal.aborted) return;
+    this.emit({
+      type: "agent_event",
+      ...this.identity(member),
+      coordinator: member === this.leader,
+      event: lifecycleSnapshot(event)
+    });
+  }
+  assertOpen() {
+    if (this.fatal !== void 0) throw this.fatal;
+    if (this.closed) throw new AgentStreamClosedError();
+    throwIfAborted(this.controller.signal);
+  }
+  fail(error) {
+    this.fatal ??= error;
+    this.controller.abort(error);
+    this.stopMembers();
+    this.changes.notify();
+  }
+  stopMember(member, reason) {
+    if (member.status === "cancelled") return;
+    member.status = "cancelled";
+    member.inputs.length = 0;
+    member.controller.abort(reason);
+    member.activeRun?.cancel(reason);
+    this.memberEvent(member, "agent_cancelled");
+    this.changes.notify();
+  }
+  stopMembers() {
+    for (const member of this.instances.values()) {
+      if (["queued", "running", "waiting", "awaiting_interaction"].includes(member.status))
+        this.stopMember(member, "Agent team closed.");
+    }
+  }
+  stopDescendants(parent, reason) {
+    const stopped = /* @__PURE__ */ new Set([parent.instanceId]);
+    for (const member of this.instances.values()) {
+      if (member.parentInstanceId !== void 0 && stopped.has(member.parentInstanceId)) {
+        stopped.add(member.instanceId);
+        this.stopMember(member, reason);
+      }
+    }
+  }
+  async settleMembers() {
+    await Promise.allSettled(
+      [...this.instances.values()].flatMap(
+        (member) => member.task === void 0 ? [] : [member.task]
+      )
+    );
+  }
+};
+
+export {
+  TeamRun
+};
+//# sourceMappingURL=chunk-SIYZDPVH.js.map