@anvia/core 1.1.1 → 1.2.0

package/dist/chunk-TIZGADU4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pipeline/pipeline.ts"],"sourcesContent":["import { z } from \"zod\";\nimport type { Agent } from \"../agent/agent\";\nimport { AgentRunBlockedError } from \"../agent/errors\";\nimport type { AgentInput, AgentRunOptions, AgentRunSettings } from \"../agent/run-types\";\nimport type { CompletionModel, CompletionModelControlsOf, JsonObject } from \"../completion\";\nimport { type ExtractOptions, extract as extractData } from \"../extractor\";\nimport { throwIfAborted } from \"../internal/abort\";\nimport { mapWithConcurrency } from \"../internal/concurrency\";\nimport type { AgentTraceOptions } from \"../observability\";\nimport { PipelineAgentSuspensionError } from \"./errors\";\nimport {\n  appendComposedGraph,\n  appendParallelBranch,\n  appendStageNode,\n  cloneGraph,\n  initialPipelineState,\n  withOutputNode,\n  withTerminalPaths,\n} from \"./graph\";\nimport { snapshotPipelineObservability, startPipelineRunObservers } from \"./observability\";\nimport {\n  childContext,\n  combineAbortSignals,\n  pipelineAbortError,\n  runNode,\n  stageContext,\n} from \"./runtime\";\nimport type {\n  ParallelOutput,\n  PipelineBatchItem,\n  PipelineBatchOptions,\n  PipelineExecutor,\n  PipelineGraph,\n  PipelineGraphNode,\n  PipelineNodePath,\n  PipelineOptions,\n  PipelineRunContext,\n  PipelineRunOptions,\n  PipelineRunResult,\n  PipelineStageContext,\n  PipelineStageMetadata,\n  PipelineState,\n  PipelineTraceInfo,\n} from \"./types\";\n\nconst internalPipelineOptions = Symbol(\"internal-pipeline-options\");\n\ntype RawResponseOf<Model> =\n  Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;\n\ntype PipelineAgentRequest<Output, Model extends CompletionModel> = AgentInput &\n  Omit<\n    AgentRunSettings<Output, RawResponseOf<Model>, CompletionModelControlsOf<Model>>,\n    \"abortSignal\"\n  >;\n\nexport type PipelineStepOptions<Input, Output> = PipelineStageMetadata & {\n  run(context: PipelineStageContext<Input>): Output | Promise<Output>;\n};\n\nexport type PipelineComposeOptions<Input, Output> = PipelineStageMetadata & {\n  pipeline: Pipeline<Input, Output>;\n};\n\nexport type PipelineParallelOptions<\n  Input,\n  Branches extends Record<string, Pipeline<Input, unknown>>,\n> = PipelineStageMetadata & {\n  branches: Branches;\n};\n\nexport type PipelineAgentOptions<\n  Input,\n  AgentOutput,\n  Model extends CompletionModel,\n> = PipelineStageMetadata & {\n  agent: Agent<AgentOutput, Model>;\n  request(\n    context: PipelineStageContext<Input>,\n  ): PipelineAgentRequest<AgentOutput, Model> | Promise<PipelineAgentRequest<AgentOutput, Model>>;\n  suspension: \"reject\";\n};\n\nexport type PipelineExtractOptions<\n  Input,\n  Extracted,\n  Model extends CompletionModel,\n> = PipelineStageMetadata &\n  Omit<ExtractOptions<Extracted, Model>, \"text\" | \"abortSignal\"> & {\n    text(context: PipelineStageContext<Input>): string | Promise<string>;\n  };\n\ntype InternalPipelineOptions<Input, Output> = {\n  [internalPipelineOptions]: {\n    executor: PipelineExecutor<Input, Output>;\n    state: PipelineState;\n    observability: PipelineOptions<Input>[\"observability\"];\n  };\n};\n\n/** Immutable, typed Pipeline with explicit stage and execution boundaries. */\nexport class Pipeline<Input, Output = Input> {\n  readonly id: string;\n  readonly name: string | undefined;\n  readonly description: string | undefined;\n  readonly metadata: JsonObject | undefined;\n  readonly observability: PipelineOptions<Input>[\"observability\"];\n\n  private readonly executor: PipelineExecutor<Input, Output>;\n  private readonly state: PipelineState;\n\n  constructor(options: PipelineOptions<Input, Output>);\n  constructor(options: PipelineOptions<Input, Output> | InternalPipelineOptions<Input, Output>) {\n    if (isInternalPipelineOptions(options)) {\n      this.executor = options[internalPipelineOptions].executor;\n      this.state = options[internalPipelineOptions].state;\n      this.observability = options[internalPipelineOptions].observability;\n    } else {\n      const id = normalizePipelineId(options.id);\n      if (!isZodSchema(options.inputSchema)) {\n        throw new TypeError(\"Pipeline inputSchema must be a Zod schema.\");\n      }\n      const inputSchema = options.inputSchema;\n      this.executor = (async (input, context) => {\n        throwIfAborted(context.abortSignal);\n        return inputSchema.parseAsync(input) as Promise<Output>;\n      }) as PipelineExecutor<Input, Output>;\n      this.state = initialPipelineState({\n        id,\n        name: options.name,\n        description: options.description,\n        metadata: options.metadata,\n      });\n      this.observability = snapshotPipelineObservability(options.observability);\n    }\n\n    const graph = this.state.graph;\n    this.id = graph.id;\n    this.name = graph.name;\n    this.description = graph.description;\n    this.metadata = graph.metadata;\n  }\n\n  step<Next>(options: PipelineStepOptions<Awaited<Output>, Next>): Pipeline<Input, Awaited<Next>> {\n    const next = appendStageNode(this.state, \"step\", options);\n    const executor = (async (input, context, pathPrefix) => {\n      const value = await this.execute(input, context, pathPrefix);\n      const path = [...pathPrefix, next.node.id];\n      return (await runNode(context, next.node, path, value, () =>\n        options.run(stageContext(value, context)),\n      )) as Awaited<Next>;\n    }) as PipelineExecutor<Input, Awaited<Next>>;\n    return this.derive(executor, next.state);\n  }\n\n  compose<Next>(\n    options: PipelineComposeOptions<Awaited<Output>, Next>,\n  ): Pipeline<Input, Awaited<Next>> {\n    const boundary = appendStageNode(this.state, \"pipeline\", options, {\n      defaultLabel: options.pipeline.name ?? options.pipeline.id,\n      pipelineId: options.pipeline.id,\n    });\n    const state = appendComposedGraph(boundary.state, boundary.node, options.pipeline.graph());\n    const executor = (async (input, context, pathPrefix) => {\n      const value = await this.execute(input, context, pathPrefix);\n      const path = [...pathPrefix, boundary.node.id];\n      return (await runNode(context, boundary.node, path, value, () =>\n        options.pipeline.execute(value, context, path),\n      )) as Awaited<Next>;\n    }) as PipelineExecutor<Input, Awaited<Next>>;\n    return this.derive(executor, state);\n  }\n\n  parallel<Branches extends Record<string, Pipeline<Awaited<Output>, unknown>>>(\n    options: PipelineParallelOptions<Awaited<Output>, Branches>,\n  ): Pipeline<Input, ParallelOutput<Branches>> {\n    const branchEntries = normalizeParallelBranches(options.branches);\n    if (branchEntries.length === 0) {\n      throw new TypeError(\"Pipeline parallel branches must not be empty.\");\n    }\n    const parallel = appendStageNode(this.state, \"parallel\", options, {\n      defaultLabel: `${branchEntries.length} parallel branches`,\n    });\n    let nextState = parallel.state;\n    const branchNodes = new Map<string, PipelineGraphNode>();\n    const terminalPaths: PipelineNodePath[] = [];\n    for (const [key, branch] of branchEntries) {\n      const appended = appendParallelBranch(nextState, parallel.node, key, branch.graph());\n      nextState = appended.state;\n      branchNodes.set(key, appended.node);\n      terminalPaths.push(...appended.terminalPaths);\n    }\n    nextState = withTerminalPaths(nextState, terminalPaths);\n\n    return this.derive<ParallelOutput<Branches>>(async (input, context, pathPrefix) => {\n      const value = await this.execute(input, context, pathPrefix);\n      const parallelPath = [...pathPrefix, parallel.node.id];\n      return runNode(context, parallel.node, parallelPath, value, async () => {\n        const controller = new AbortController();\n        const combined = combineAbortSignals(context.abortSignal, controller.signal);\n        const branchContext = childContext(context, combined.signal);\n        let firstError: unknown;\n        const promises = branchEntries.map(async ([key, branch]) => {\n          const node = branchNodes.get(key) as PipelineGraphNode;\n          const path = [...parallelPath, node.id];\n          try {\n            const output = await runNode(branchContext, node, path, value, () =>\n              branch.execute(value, branchContext, path),\n            );\n            return [key, output] as const;\n          } catch (error) {\n            if (firstError === undefined) firstError = error;\n            if (!controller.signal.aborted) controller.abort(error);\n            throw error;\n          }\n        });\n\n        const settled = await Promise.allSettled(promises);\n        combined.dispose();\n        if (context.abortSignal?.aborted === true) {\n          throw pipelineAbortError(context.abortSignal);\n        }\n        if (firstError !== undefined) throw firstError;\n        return Object.fromEntries(\n          settled.map(\n            (result) => (result as PromiseFulfilledResult<readonly [string, unknown]>).value,\n          ),\n        ) as ParallelOutput<Branches>;\n      });\n    }, nextState);\n  }\n\n  agent<AgentOutput, Model extends CompletionModel>(\n    options: PipelineAgentOptions<Awaited<Output>, AgentOutput, Model>,\n  ): Pipeline<Input, AgentOutput> {\n    if (options.suspension !== \"reject\") {\n      throw new TypeError('Pipeline Agent stages require suspension: \"reject\".');\n    }\n    const next = appendStageNode(this.state, \"agent\", options, {\n      defaultLabel: options.agent.name ?? options.agent.id,\n      agentId: options.agent.id,\n      agentName: options.agent.name,\n    });\n    return this.derive<AgentOutput>(async (input, context, pathPrefix) => {\n      const value = await this.execute(input, context, pathPrefix);\n      const path = [...pathPrefix, next.node.id];\n      return runNode(context, next.node, path, value, async (stageTrace) => {\n        const request = await options.request(stageContext(value, context));\n        const response = await options.agent.generate({\n          ...request,\n          trace: withPipelineParentTrace(\n            request.trace,\n            stageTrace,\n            options.agent.observability?.primaryTrace,\n          ),\n          abortSignal: context.abortSignal,\n        } as AgentRunOptions<AgentOutput, RawResponseOf<Model>, CompletionModelControlsOf<Model>>);\n        if (response.type === \"interaction\") {\n          throw new PipelineAgentSuspensionError(response);\n        }\n        if (response.type === \"blocked\") {\n          throw new AgentRunBlockedError(response);\n        }\n        return response.output;\n      });\n    }, next.state);\n  }\n\n  extract<Extracted, Model extends CompletionModel>(\n    options: PipelineExtractOptions<Awaited<Output>, Extracted, Model>,\n  ): Pipeline<Input, Extracted> {\n    const next = appendStageNode(this.state, \"extractor\", options);\n    return this.derive<Extracted>(async (input, context, pathPrefix) => {\n      const value = await this.execute(input, context, pathPrefix);\n      const path = [...pathPrefix, next.node.id];\n      return runNode(context, next.node, path, value, async () => {\n        const text = await options.text(stageContext(value, context));\n        const result = await extractData({\n          model: options.model,\n          text,\n          outputSchema: options.outputSchema,\n          instructions: options.instructions,\n          retries: options.retries,\n          temperature: options.temperature,\n          maxTokens: options.maxTokens,\n          providerOptions: options.providerOptions,\n          abortSignal: context.abortSignal,\n        });\n        return result.output;\n      });\n    }, next.state);\n  }\n\n  async run(options: PipelineRunOptions<Input>): Promise<PipelineRunResult<Output>> {\n    const runId = normalizeRunId(options.runId ?? globalThis.crypto.randomUUID());\n    const startedAt = Date.now();\n    const observability = await startPipelineRunObservers(\n      this.observability?.observers ?? {},\n      {\n        runId,\n        pipelineId: this.id,\n        pipelineName: this.name,\n        pipelineDescription: this.description,\n        pipelineMetadata: this.metadata,\n        runMetadata: options.metadata,\n        trace: options.trace,\n        input: options.input,\n      },\n      {\n        primaryTrace: this.observability?.primaryTrace,\n        errorPolicy: this.observability?.errorPolicy ?? \"ignore\",\n      },\n    );\n    const context: PipelineRunContext = {\n      runId,\n      pipelineId: this.id,\n      runMetadata: options.metadata,\n      abortSignal: options.abortSignal,\n      observer: options.observer,\n      failOnObserverError: options.failOnObserverError === true,\n      observability,\n    };\n    try {\n      throwIfAborted(context.abortSignal);\n      const output = await this.execute(options.input, context, []);\n      throwIfAborted(context.abortSignal);\n      await observability.end({\n        runId,\n        pipelineId: this.id,\n        output,\n        durationMs: Date.now() - startedAt,\n      });\n      return observability.trace === undefined\n        ? { runId, output }\n        : { runId, output, trace: observability.trace };\n    } catch (error) {\n      await observability.error({\n        runId,\n        pipelineId: this.id,\n        status: context.abortSignal?.aborted === true ? \"cancelled\" : \"failed\",\n        error,\n        durationMs: Date.now() - startedAt,\n      });\n      throw error;\n    }\n  }\n\n  async runBatch(options: PipelineBatchOptions<Input>): Promise<Array<PipelineBatchItem<Output>>> {\n    throwIfAborted(options.abortSignal);\n    return mapWithConcurrency([...options.inputs], options.concurrency, async (input) => {\n      const runId = globalThis.crypto.randomUUID();\n      try {\n        const result = await this.run({\n          input,\n          runId,\n          metadata: options.metadata,\n          trace: options.trace,\n          abortSignal: options.abortSignal,\n          observer: options.observer,\n          failOnObserverError: options.failOnObserverError,\n        });\n        return { status: \"completed\", ...result } as const;\n      } catch (error) {\n        if (options.abortSignal?.aborted === true) {\n          throw pipelineAbortError(options.abortSignal);\n        }\n        return { status: \"failed\", runId, error } as const;\n      }\n    });\n  }\n\n  graph(): PipelineGraph {\n    return cloneGraph(withOutputNode(this.state));\n  }\n\n  private derive<DerivedOutput>(\n    executor: PipelineExecutor<Input, DerivedOutput>,\n    state: PipelineState,\n  ): Pipeline<Input, DerivedOutput> {\n    return createDerivedPipeline(executor, state, this.observability);\n  }\n\n  private async execute(\n    input: Input,\n    context: PipelineRunContext,\n    pathPrefix: PipelineNodePath,\n  ): Promise<Awaited<Output>> {\n    throwIfAborted(context.abortSignal);\n    return (await this.executor(input, context, pathPrefix)) as Awaited<Output>;\n  }\n}\n\nfunction createDerivedPipeline<Input, Output>(\n  executor: PipelineExecutor<Input, Output>,\n  state: PipelineState,\n  observability: PipelineOptions<Input>[\"observability\"],\n): Pipeline<Input, Output> {\n  const options: InternalPipelineOptions<Input, Output> = {\n    [internalPipelineOptions]: { executor, state, observability },\n  };\n  return new Pipeline<Input, Output>(options as unknown as PipelineOptions<Input, Output>);\n}\n\nfunction withPipelineParentTrace(\n  trace: AgentTraceOptions | undefined,\n  parent: PipelineTraceInfo | undefined,\n  agentPrimaryTrace: string | undefined,\n): AgentTraceOptions | undefined {\n  if (parent?.traceId === undefined) return trace;\n  if (parent.observer !== agentPrimaryTrace) return trace;\n  if (trace?.traceId !== undefined && trace.traceId !== parent.traceId) return trace;\n  return {\n    ...trace,\n    traceId: parent.traceId,\n    ...(trace?.parentObservationId !== undefined || parent.observationId === undefined\n      ? {}\n      : { parentObservationId: parent.observationId }),\n  };\n}\n\nfunction isInternalPipelineOptions<Input, Output>(\n  options: PipelineOptions<Input, Output> | InternalPipelineOptions<Input, Output>,\n): options is InternalPipelineOptions<Input, Output> {\n  return internalPipelineOptions in options;\n}\n\nfunction isZodSchema(value: unknown): value is z.ZodType {\n  return value instanceof z.ZodType;\n}\n\nfunction normalizePipelineId(id: string): string {\n  if (typeof id !== \"string\") {\n    throw new TypeError(\"Pipeline id must be a string.\");\n  }\n  const normalized = id.trim();\n  if (normalized.length === 0) {\n    throw new TypeError(\"Pipeline id must be a non-empty string.\");\n  }\n  return normalized;\n}\n\nfunction normalizeRunId(runId: string): string {\n  if (typeof runId !== \"string\") {\n    throw new TypeError(\"Pipeline runId must be a string.\");\n  }\n  const normalized = runId.trim();\n  if (normalized.length === 0) {\n    throw new TypeError(\"Pipeline runId must be a non-empty string.\");\n  }\n  return normalized;\n}\n\nfunction normalizeParallelBranches<Branch>(\n  branches: Readonly<Record<string, Branch>>,\n): Array<readonly [string, Branch]> {\n  const entries: Array<readonly [string, Branch]> = [];\n  const ids = new Set<string>();\n  for (const key of Object.keys(branches)) {\n    const pipeline = branches[key] as Branch;\n    const id = key.trim();\n    if (id.length === 0) {\n      throw new TypeError(\"Pipeline parallel branch id must be a non-empty string.\");\n    }\n    if (ids.has(id)) {\n      throw new TypeError(`Pipeline parallel branch id \"${id}\" is already registered.`);\n    }\n    ids.add(id);\n    if (id !== key) {\n      throw new TypeError(\"Pipeline parallel branch ids must not contain surrounding whitespace.\");\n    }\n    entries.push([id, pipeline]);\n  }\n  return entries;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-TP3MCUXS.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-TP3MCUXS.js.map

package/dist/chunk-TP3MCUXS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-TSPQD5HW.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-PT777EQ3.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-TSPQD5HW.js.map