@anvia/core 1.1.1 → 1.2.0

package/dist/chunk-SC4SUIEY.js

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

package/dist/chunk-SC4SUIEY.js.map

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

package/dist/chunk-SQAAVYJG.js

@@ -0,0 +1,12 @@
+// src/schema/zod-schema.ts
+import { toJSONSchema } from "zod";
+function toProviderJsonSchema(schema, options = {}) {
+  const jsonSchema = toJSONSchema(schema, options);
+  const { $schema: _schema, ...providerSchema } = jsonSchema;
+  return providerSchema;
+}
+
+export {
+  toProviderJsonSchema
+};
+//# sourceMappingURL=chunk-SQAAVYJG.js.map

package/dist/chunk-SQAAVYJG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema/zod-schema.ts"],"sourcesContent":["import { toJSONSchema, type z } from \"zod\";\nimport type { JsonObject } from \"../completion/index\";\n\nexport type ZodSchema<T = unknown> = z.ZodType<T>;\n\nexport function toProviderJsonSchema(\n  schema: z.ZodType,\n  options: { io?: \"input\" | \"output\" } = {},\n): JsonObject {\n  const jsonSchema = toJSONSchema(schema, options) as JsonObject;\n  const { $schema: _schema, ...providerSchema } = jsonSchema;\n  return providerSchema;\n}\n"],"mappings":";AAAA,SAAS,oBAA4B;AAK9B,SAAS,qBACd,QACA,UAAuC,CAAC,GAC5B;AACZ,QAAM,aAAa,aAAa,QAAQ,OAAO;AAC/C,QAAM,EAAE,SAAS,SAAS,GAAG,eAAe,IAAI;AAChD,SAAO;AACT;","names":[]}

package/dist/chunk-SXE4J43E.js

@@ -0,0 +1,59 @@
+// src/internal/agent-runtime/structured-output.ts
+var JSON_FENCE_START = "```json\n";
+var JSON_FENCE_CRLF_START = "```json\r\n";
+var UNLABELED_FENCE_START = "```\n";
+var UNLABELED_FENCE_CRLF_START = "```\r\n";
+var FENCE_END = "\n```";
+var STRUCTURED_OUTPUT_RETRY_PROMPT = "Your previous response was invalid structured output. Return only raw JSON that matches the supplied JSON schema. Do not use Markdown fences or include commentary.";
+var STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT = "Your previous response exceeded the provider output limit. Return substantially shorter raw JSON that matches the supplied JSON schema. Do not use Markdown fences or include commentary.";
+var STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH = 8192;
+var STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER = "\n...[output omitted]...\n";
+function structuredOutputRepairPreview(text) {
+  if (text.length <= STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH) {
+    return { text, includedOutputLength: text.length };
+  }
+  const availableLength = STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH - STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER.length;
+  const headLength = Math.ceil(availableLength / 2);
+  const tailLength = availableLength - headLength;
+  return {
+    text: `${text.slice(0, headLength)}${STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER}${text.slice(-tailLength)}`,
+    includedOutputLength: headLength + tailLength
+  };
+}
+function normalizeStructuredOutput(text) {
+  const trimmed = text.trim();
+  const opening = fenceOpening(trimmed);
+  if (opening === void 0 || !trimmed.endsWith(FENCE_END)) {
+    return { text: trimmed, format: "raw" };
+  }
+  const closingStart = trimmed.length - 3;
+  const precedingNewline = closingStart - 1;
+  const contentEnd = trimmed[precedingNewline - 1] === "\r" ? precedingNewline - 1 : precedingNewline;
+  return {
+    text: trimmed.slice(opening.length, contentEnd).trim(),
+    format: opening.format
+  };
+}
+function fenceOpening(text) {
+  if (text.startsWith(JSON_FENCE_START)) {
+    return { length: JSON_FENCE_START.length, format: "json-fence" };
+  }
+  if (text.startsWith(JSON_FENCE_CRLF_START)) {
+    return { length: JSON_FENCE_CRLF_START.length, format: "json-fence" };
+  }
+  if (text.startsWith(UNLABELED_FENCE_START)) {
+    return { length: UNLABELED_FENCE_START.length, format: "unlabeled-fence" };
+  }
+  if (text.startsWith(UNLABELED_FENCE_CRLF_START)) {
+    return { length: UNLABELED_FENCE_CRLF_START.length, format: "unlabeled-fence" };
+  }
+  return void 0;
+}
+
+export {
+  STRUCTURED_OUTPUT_RETRY_PROMPT,
+  STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT,
+  structuredOutputRepairPreview,
+  normalizeStructuredOutput
+};
+//# sourceMappingURL=chunk-SXE4J43E.js.map

package/dist/chunk-SXE4J43E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/agent-runtime/structured-output.ts"],"sourcesContent":["import type { AgentStructuredOutputFormat } from \"../../agent/errors\";\n\nconst JSON_FENCE_START = \"```json\\n\";\nconst JSON_FENCE_CRLF_START = \"```json\\r\\n\";\nconst UNLABELED_FENCE_START = \"```\\n\";\nconst UNLABELED_FENCE_CRLF_START = \"```\\r\\n\";\nconst FENCE_END = \"\\n```\";\n\nexport const STRUCTURED_OUTPUT_RETRY_PROMPT =\n  \"Your previous response was invalid structured output. Return only raw JSON that matches the supplied JSON schema. Do not use Markdown fences or include commentary.\";\n\nexport const STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT =\n  \"Your previous response exceeded the provider output limit. Return substantially shorter raw JSON that matches the supplied JSON schema. Do not use Markdown fences or include commentary.\";\n\nconst STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH = 8_192;\nconst STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER = \"\\n...[output omitted]...\\n\";\n\nexport type StructuredOutputRepairPreview = Readonly<{\n  text: string;\n  includedOutputLength: number;\n}>;\n\nexport function structuredOutputRepairPreview(text: string): StructuredOutputRepairPreview {\n  if (text.length <= STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH) {\n    return { text, includedOutputLength: text.length };\n  }\n  const availableLength =\n    STRUCTURED_OUTPUT_REPAIR_PREVIEW_MAX_LENGTH - STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER.length;\n  const headLength = Math.ceil(availableLength / 2);\n  const tailLength = availableLength - headLength;\n  return {\n    text: `${text.slice(0, headLength)}${STRUCTURED_OUTPUT_REPAIR_PREVIEW_MARKER}${text.slice(-tailLength)}`,\n    includedOutputLength: headLength + tailLength,\n  };\n}\n\nexport type NormalizedStructuredOutput = Readonly<{\n  text: string;\n  format: AgentStructuredOutputFormat;\n}>;\n\nexport function normalizeStructuredOutput(text: string): NormalizedStructuredOutput {\n  const trimmed = text.trim();\n  const opening = fenceOpening(trimmed);\n  if (opening === undefined || !trimmed.endsWith(FENCE_END)) {\n    return { text: trimmed, format: \"raw\" };\n  }\n\n  const closingStart = trimmed.length - 3;\n  const precedingNewline = closingStart - 1;\n  const contentEnd =\n    trimmed[precedingNewline - 1] === \"\\r\" ? precedingNewline - 1 : precedingNewline;\n  return {\n    text: trimmed.slice(opening.length, contentEnd).trim(),\n    format: opening.format,\n  };\n}\n\nfunction fenceOpening(\n  text: string,\n): Readonly<{ length: number; format: Exclude<AgentStructuredOutputFormat, \"raw\"> }> | undefined {\n  if (text.startsWith(JSON_FENCE_START)) {\n    return { length: JSON_FENCE_START.length, format: \"json-fence\" };\n  }\n  if (text.startsWith(JSON_FENCE_CRLF_START)) {\n    return { length: JSON_FENCE_CRLF_START.length, format: \"json-fence\" };\n  }\n  if (text.startsWith(UNLABELED_FENCE_START)) {\n    return { length: UNLABELED_FENCE_START.length, format: \"unlabeled-fence\" };\n  }\n  if (text.startsWith(UNLABELED_FENCE_CRLF_START)) {\n    return { length: UNLABELED_FENCE_CRLF_START.length, format: \"unlabeled-fence\" };\n  }\n  return undefined;\n}\n"],"mappings":";AAEA,IAAM,mBAAmB;AACzB,IAAM,wBAAwB;AAC9B,IAAM,wBAAwB;AAC9B,IAAM,6BAA6B;AACnC,IAAM,YAAY;AAEX,IAAM,iCACX;AAEK,IAAM,2CACX;AAEF,IAAM,8CAA8C;AACpD,IAAM,0CAA0C;AAOzC,SAAS,8BAA8B,MAA6C;AACzF,MAAI,KAAK,UAAU,6CAA6C;AAC9D,WAAO,EAAE,MAAM,sBAAsB,KAAK,OAAO;AAAA,EACnD;AACA,QAAM,kBACJ,8CAA8C,wCAAwC;AACxF,QAAM,aAAa,KAAK,KAAK,kBAAkB,CAAC;AAChD,QAAM,aAAa,kBAAkB;AACrC,SAAO;AAAA,IACL,MAAM,GAAG,KAAK,MAAM,GAAG,UAAU,CAAC,GAAG,uCAAuC,GAAG,KAAK,MAAM,CAAC,UAAU,CAAC;AAAA,IACtG,sBAAsB,aAAa;AAAA,EACrC;AACF;AAOO,SAAS,0BAA0B,MAA0C;AAClF,QAAM,UAAU,KAAK,KAAK;AAC1B,QAAM,UAAU,aAAa,OAAO;AACpC,MAAI,YAAY,UAAa,CAAC,QAAQ,SAAS,SAAS,GAAG;AACzD,WAAO,EAAE,MAAM,SAAS,QAAQ,MAAM;AAAA,EACxC;AAEA,QAAM,eAAe,QAAQ,SAAS;AACtC,QAAM,mBAAmB,eAAe;AACxC,QAAM,aACJ,QAAQ,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,IAAI;AAClE,SAAO;AAAA,IACL,MAAM,QAAQ,MAAM,QAAQ,QAAQ,UAAU,EAAE,KAAK;AAAA,IACrD,QAAQ,QAAQ;AAAA,EAClB;AACF;AAEA,SAAS,aACP,MAC+F;AAC/F,MAAI,KAAK,WAAW,gBAAgB,GAAG;AACrC,WAAO,EAAE,QAAQ,iBAAiB,QAAQ,QAAQ,aAAa;AAAA,EACjE;AACA,MAAI,KAAK,WAAW,qBAAqB,GAAG;AAC1C,WAAO,EAAE,QAAQ,sBAAsB,QAAQ,QAAQ,aAAa;AAAA,EACtE;AACA,MAAI,KAAK,WAAW,qBAAqB,GAAG;AAC1C,WAAO,EAAE,QAAQ,sBAAsB,QAAQ,QAAQ,kBAAkB;AAAA,EAC3E;AACA,MAAI,KAAK,WAAW,0BAA0B,GAAG;AAC/C,WAAO,EAAE,QAAQ,2BAA2B,QAAQ,QAAQ,kBAAkB;AAAA,EAChF;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-EFLT7XZD.js → chunk-SYULMZGL.js}

@@ -1,11 +1,13 @@
 import {
   assertJsonObject
-} from "./chunk-7JLAIN6E.js";
+} from "./chunk-4ONUNWGC.js";
 import {
   resolveRetryOptions,
-  runWithRetries,
+  runWithRetries
+} from "./chunk-POXHJF3H.js";
+import {
   throwIfAborted
-} from "./chunk-3RWESPUG.js";
+} from "./chunk-USRKPEQN.js";
 
 // src/speech-generation/generate-speech.ts
 async function generateSpeech(options) {
@@ -48,4 +50,4 @@ function assertNonEmptyString(value, name) {
 export {
   generateSpeech
 };
-//# sourceMappingURL=chunk-EFLT7XZD.js.map
+//# sourceMappingURL=chunk-SYULMZGL.js.map

package/dist/{chunk-EFLT7XZD.js.map → chunk-SYULMZGL.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/speech-generation/generate-speech.ts"],"sourcesContent":["import type { JsonObject } from \"../completion/types\";\nimport { throwIfAborted } from \"../internal/abort\";\nimport { assertJsonObject } from \"../internal/json-object\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport {\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  runWithRetries,\n} from \"../retry\";\nimport type {\n  SpeechGenerationModel,\n  SpeechGenerationRequest,\n  SpeechGenerationResult,\n} from \"./types\";\n\nexport type GenerateSpeechOptions<Model extends SpeechGenerationModel = SpeechGenerationModel> = {\n  model: Model;\n  text: string;\n  voice: string;\n  speed?: number | undefined;\n  providerOptions?: JsonObject | undefined;\n  retries?: RetrySetting | undefined;\n  abortSignal?: AbortSignal | undefined;\n};\n\ntype RawResponseOf<Model> =\n  Model extends SpeechGenerationModel<infer RawResponse> ? RawResponse : unknown;\n\nexport async function generateSpeech<Model extends SpeechGenerationModel>(\n  options: GenerateSpeechOptions<Model>,\n): Promise<SpeechGenerationResult<RawResponseOf<Model>>> {\n  assertNonEmptyString(options.text, \"Speech text\");\n  assertNonEmptyString(options.voice, \"Speech voice\");\n  throwIfAborted(options.abortSignal);\n  const speed = options.speed ?? 1;\n  if (!Number.isFinite(speed) || speed <= 0) {\n    throw new RangeError(\"Speech speed must be a positive finite number.\");\n  }\n\n  const request: SpeechGenerationRequest = { text: options.text, voice: options.voice, speed };\n  if (options.providerOptions !== undefined) {\n    assertJsonObject(options.providerOptions, \"providerOptions\");\n    request.providerOptions = options.providerOptions;\n  }\n  return runWithRetries(\n    () => {\n      throwIfAborted(options.abortSignal);\n      return options.model.speechGeneration(\n        request,\n        modelCallOptions(options.abortSignal),\n      ) as Promise<SpeechGenerationResult<RawResponseOf<Model>>>;\n    },\n    resolveRetries(options.retries),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n}\n\nfunction resolveRetries(setting: RetrySetting | undefined): ResolvedRetryOptions | undefined {\n  return setting === undefined || setting === false ? undefined : resolveRetryOptions(setting);\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nfunction assertNonEmptyString(value: string, name: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`${name} must be a non-empty string.`);\n  }\n}\n"],"mappings":";;;;;;;;;;AA6BA,eAAsB,eACpB,SACuD;AACvD,uBAAqB,QAAQ,MAAM,aAAa;AAChD,uBAAqB,QAAQ,OAAO,cAAc;AAClD,iBAAe,QAAQ,WAAW;AAClC,QAAM,QAAQ,QAAQ,SAAS;AAC/B,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GAAG;AACzC,UAAM,IAAI,WAAW,gDAAgD;AAAA,EACvE;AAEA,QAAM,UAAmC,EAAE,MAAM,QAAQ,MAAM,OAAO,QAAQ,OAAO,MAAM;AAC3F,MAAI,QAAQ,oBAAoB,QAAW;AACzC,qBAAiB,QAAQ,iBAAiB,iBAAiB;AAC3D,YAAQ,kBAAkB,QAAQ;AAAA,EACpC;AACA,SAAO;AAAA,IACL,MAAM;AACJ,qBAAe,QAAQ,WAAW;AAClC,aAAO,QAAQ,MAAM;AAAA,QACnB;AAAA,QACA,iBAAiB,QAAQ,WAAW;AAAA,MACtC;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,OAAO;AAAA,IAC9B,EAAE,WAAW,OAAO,aAAa,QAAQ,YAAY;AAAA,EACvD;AACF;AAEA,SAAS,eAAe,SAAqE;AAC3F,SAAO,YAAY,UAAa,YAAY,QAAQ,SAAY,oBAAoB,OAAO;AAC7F;AAEA,SAAS,iBAAiB,aAAoE;AAC5F,SAAO,gBAAgB,SAAY,SAAY,EAAE,YAAY;AAC/D;AAEA,SAAS,qBAAqB,OAAe,MAAoB;AAC/D,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,UAAU,GAAG,IAAI,8BAA8B;AAAA,EAC3D;AACF;","names":[]}
+{"version":3,"sources":["../src/speech-generation/generate-speech.ts"],"sourcesContent":["import type { JsonObject } from \"../completion/types\";\nimport { throwIfAborted } from \"../internal/abort\";\nimport { assertJsonObject } from \"../internal/json-object\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport {\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  runWithRetries,\n} from \"../retry\";\nimport type {\n  SpeechGenerationModel,\n  SpeechGenerationRequest,\n  SpeechGenerationResult,\n} from \"./types\";\n\nexport type GenerateSpeechOptions<Model extends SpeechGenerationModel = SpeechGenerationModel> = {\n  model: Model;\n  text: string;\n  voice: string;\n  speed?: number | undefined;\n  providerOptions?: JsonObject | undefined;\n  retries?: RetrySetting | undefined;\n  abortSignal?: AbortSignal | undefined;\n};\n\ntype RawResponseOf<Model> =\n  Model extends SpeechGenerationModel<infer RawResponse> ? RawResponse : unknown;\n\nexport async function generateSpeech<Model extends SpeechGenerationModel>(\n  options: GenerateSpeechOptions<Model>,\n): Promise<SpeechGenerationResult<RawResponseOf<Model>>> {\n  assertNonEmptyString(options.text, \"Speech text\");\n  assertNonEmptyString(options.voice, \"Speech voice\");\n  throwIfAborted(options.abortSignal);\n  const speed = options.speed ?? 1;\n  if (!Number.isFinite(speed) || speed <= 0) {\n    throw new RangeError(\"Speech speed must be a positive finite number.\");\n  }\n\n  const request: SpeechGenerationRequest = { text: options.text, voice: options.voice, speed };\n  if (options.providerOptions !== undefined) {\n    assertJsonObject(options.providerOptions, \"providerOptions\");\n    request.providerOptions = options.providerOptions;\n  }\n  return runWithRetries(\n    () => {\n      throwIfAborted(options.abortSignal);\n      return options.model.speechGeneration(\n        request,\n        modelCallOptions(options.abortSignal),\n      ) as Promise<SpeechGenerationResult<RawResponseOf<Model>>>;\n    },\n    resolveRetries(options.retries),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n}\n\nfunction resolveRetries(setting: RetrySetting | undefined): ResolvedRetryOptions | undefined {\n  return setting === undefined || setting === false ? undefined : resolveRetryOptions(setting);\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nfunction assertNonEmptyString(value: string, name: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`${name} must be a non-empty string.`);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AA6BA,eAAsB,eACpB,SACuD;AACvD,uBAAqB,QAAQ,MAAM,aAAa;AAChD,uBAAqB,QAAQ,OAAO,cAAc;AAClD,iBAAe,QAAQ,WAAW;AAClC,QAAM,QAAQ,QAAQ,SAAS;AAC/B,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GAAG;AACzC,UAAM,IAAI,WAAW,gDAAgD;AAAA,EACvE;AAEA,QAAM,UAAmC,EAAE,MAAM,QAAQ,MAAM,OAAO,QAAQ,OAAO,MAAM;AAC3F,MAAI,QAAQ,oBAAoB,QAAW;AACzC,qBAAiB,QAAQ,iBAAiB,iBAAiB;AAC3D,YAAQ,kBAAkB,QAAQ;AAAA,EACpC;AACA,SAAO;AAAA,IACL,MAAM;AACJ,qBAAe,QAAQ,WAAW;AAClC,aAAO,QAAQ,MAAM;AAAA,QACnB;AAAA,QACA,iBAAiB,QAAQ,WAAW;AAAA,MACtC;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,OAAO;AAAA,IAC9B,EAAE,WAAW,OAAO,aAAa,QAAQ,YAAY;AAAA,EACvD;AACF;AAEA,SAAS,eAAe,SAAqE;AAC3F,SAAO,YAAY,UAAa,YAAY,QAAQ,SAAY,oBAAoB,OAAO;AAC7F;AAEA,SAAS,iBAAiB,aAAoE;AAC5F,SAAO,gBAAgB,SAAY,SAAY,EAAE,YAAY;AAC/D;AAEA,SAAS,qBAAqB,OAAe,MAAoB;AAC/D,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,UAAU,GAAG,IAAI,8BAA8B;AAAA,EAC3D;AACF;","names":[]}

package/dist/chunk-T4KS577P.js

@@ -0,0 +1,58 @@
+import {
+  lifecycleSnapshot
+} from "./chunk-KFAVEL5F.js";
+import {
+  parseMessage,
+  parseMessages
+} from "./chunk-BONQTXRQ.js";
+
+// src/internal/team-runtime/member.ts
+function memberSummary(member) {
+  return {
+    instanceId: member.instanceId,
+    agentId: member.agent.id,
+    name: member.name,
+    depth: member.depth,
+    status: member.status,
+    usage: lifecycleSnapshot(member.usage),
+    ...member.parentInstanceId === void 0 ? {} : { parentInstanceId: member.parentInstanceId },
+    ...member.outcome === void 0 ? {} : { outcome: lifecycleSnapshot(member.outcome) },
+    ...member.error === void 0 ? {} : { error: member.error }
+  };
+}
+function steeringMessages(input) {
+  if (typeof input !== "object" || input === null || input.prompt === void 0 === (input.messages === void 0)) {
+    throw new TypeError("Agent team steering requires exactly one of prompt or messages.");
+  }
+  const messages = input.prompt === void 0 ? parseMessages(input.messages) : [
+    parseMessage(
+      typeof input.prompt === "string" ? { role: "user", content: input.prompt } : input.prompt
+    )
+  ];
+  if (messages.length === 0 || messages.some((message) => message.role !== "user")) {
+    throw new TypeError("Agent team steering requires user messages.");
+  }
+  return messages;
+}
+function agentMessageInput(message) {
+  return {
+    id: message.id,
+    submitted: false,
+    message,
+    messages: [
+      {
+        role: "user",
+        content: `Message from another agent (not a user approval):
+${JSON.stringify(message)}`,
+        metadata: { anvia: { agentMessage: { ...message } } }
+      }
+    ]
+  };
+}
+
+export {
+  memberSummary,
+  steeringMessages,
+  agentMessageInput
+};
+//# sourceMappingURL=chunk-T4KS577P.js.map

package/dist/chunk-T4KS577P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/team-runtime/member.ts"],"sourcesContent":["import type {\n  AgentTeamMemberStatus,\n  AgentTeamMemberSummary,\n  AgentTeamMessage,\n} from \"../../agent/team/types\";\nimport type { AgentOutcome, AgentSteerInput } from \"../../agent/run-types\";\nimport type { Message, UserMessage } from \"../../completion\";\nimport { parseMessage, parseMessages, Usage } from \"../../completion\";\nimport type { AgentRun } from \"../agent-runtime/agent-run\";\nimport type { Agent } from \"../../agent/agent\";\nimport { lifecycleSnapshot } from \"../../agent/lifecycle\";\n\nexport type TeamInput = {\n  id: string;\n  messages: UserMessage[];\n  message?: AgentTeamMessage;\n  submitted: boolean;\n};\n\nexport type TeamMember = {\n  instanceId: string;\n  parentInstanceId?: string;\n  depth: number;\n  definition: Agent<unknown>;\n  name: string;\n  agent: Agent<unknown>;\n  status: AgentTeamMemberStatus;\n  history: Message[];\n  inputs: TeamInput[];\n  receipts: Map<string, TeamInput>;\n  controller: AbortController;\n  release?: (() => void) | undefined;\n  task?: Promise<void> | undefined;\n  activeRun?: AgentRun<unknown> | undefined;\n  runId?: string | undefined;\n  outcome?: Exclude<AgentOutcome<unknown>, { type: \"interaction\" }>;\n  error?: unknown;\n  usage: Usage;\n  notifications: { from: string; type: \"message\" | \"outcome\"; id: string }[];\n};\n\nexport function memberSummary(member: TeamMember): AgentTeamMemberSummary {\n  return {\n    instanceId: member.instanceId,\n    agentId: member.agent.id,\n    name: member.name,\n    depth: member.depth,\n    status: member.status,\n    usage: lifecycleSnapshot(member.usage),\n    ...(member.parentInstanceId === undefined ? {} : { parentInstanceId: member.parentInstanceId }),\n    ...(member.outcome === undefined ? {} : { outcome: lifecycleSnapshot(member.outcome) }),\n    ...(member.error === undefined ? {} : { error: member.error }),\n  };\n}\n\nexport function steeringMessages(input: AgentSteerInput): UserMessage[] {\n  if (\n    typeof input !== \"object\" ||\n    input === null ||\n    (input.prompt === undefined) === (input.messages === undefined)\n  ) {\n    throw new TypeError(\"Agent team steering requires exactly one of prompt or messages.\");\n  }\n  const messages =\n    input.prompt === undefined\n      ? parseMessages(input.messages)\n      : [\n          parseMessage(\n            typeof input.prompt === \"string\"\n              ? { role: \"user\", content: input.prompt }\n              : input.prompt,\n          ),\n        ];\n  if (messages.length === 0 || messages.some((message) => message.role !== \"user\")) {\n    throw new TypeError(\"Agent team steering requires user messages.\");\n  }\n  return messages as UserMessage[];\n}\n\nexport function agentMessageInput(message: AgentTeamMessage): TeamInput {\n  return {\n    id: message.id,\n    submitted: false,\n    message,\n    messages: [\n      {\n        role: \"user\",\n        content: `Message from another agent (not a user approval):\\n${JSON.stringify(message)}`,\n        metadata: { anvia: { agentMessage: { ...message } } },\n      },\n    ],\n  };\n}\n"],"mappings":";;;;;;;;;AAyCO,SAAS,cAAc,QAA4C;AACxE,SAAO;AAAA,IACL,YAAY,OAAO;AAAA,IACnB,SAAS,OAAO,MAAM;AAAA,IACtB,MAAM,OAAO;AAAA,IACb,OAAO,OAAO;AAAA,IACd,QAAQ,OAAO;AAAA,IACf,OAAO,kBAAkB,OAAO,KAAK;AAAA,IACrC,GAAI,OAAO,qBAAqB,SAAY,CAAC,IAAI,EAAE,kBAAkB,OAAO,iBAAiB;AAAA,IAC7F,GAAI,OAAO,YAAY,SAAY,CAAC,IAAI,EAAE,SAAS,kBAAkB,OAAO,OAAO,EAAE;AAAA,IACrF,GAAI,OAAO,UAAU,SAAY,CAAC,IAAI,EAAE,OAAO,OAAO,MAAM;AAAA,EAC9D;AACF;AAEO,SAAS,iBAAiB,OAAuC;AACtE,MACE,OAAO,UAAU,YACjB,UAAU,QACT,MAAM,WAAW,YAAgB,MAAM,aAAa,SACrD;AACA,UAAM,IAAI,UAAU,iEAAiE;AAAA,EACvF;AACA,QAAM,WACJ,MAAM,WAAW,SACb,cAAc,MAAM,QAAQ,IAC5B;AAAA,IACE;AAAA,MACE,OAAO,MAAM,WAAW,WACpB,EAAE,MAAM,QAAQ,SAAS,MAAM,OAAO,IACtC,MAAM;AAAA,IACZ;AAAA,EACF;AACN,MAAI,SAAS,WAAW,KAAK,SAAS,KAAK,CAAC,YAAY,QAAQ,SAAS,MAAM,GAAG;AAChF,UAAM,IAAI,UAAU,6CAA6C;AAAA,EACnE;AACA,SAAO;AACT;AAEO,SAAS,kBAAkB,SAAsC;AACtE,SAAO;AAAA,IACL,IAAI,QAAQ;AAAA,IACZ,WAAW;AAAA,IACX;AAAA,IACA,UAAU;AAAA,MACR;AAAA,QACE,MAAM;AAAA,QACN,SAAS;AAAA,EAAsD,KAAK,UAAU,OAAO,CAAC;AAAA,QACtF,UAAU,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,QAAQ,EAAE,EAAE;AAAA,MACtD;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-TFIOU6UR.js

@@ -0,0 +1,78 @@
+import {
+  chunkText
+} from "./chunk-GPVXCY5I.js";
+
+// src/documents/text-document.ts
+function chunkTextDocuments(options) {
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError("chunkTextDocuments options must contain a documents array");
+  }
+  const documents = options.documents;
+  if (!Array.isArray(documents)) {
+    throw new TypeError("chunkTextDocuments options must contain a documents array");
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const chunks = [];
+  for (const document of documents) {
+    validateDocument(document, ids);
+    chunks.push(...chunkDocument(document, options.chunking));
+  }
+  return chunks;
+}
+function validateDocument(document, ids) {
+  if (typeof document !== "object" || document === null) {
+    throw new TypeError("Text documents must be objects");
+  }
+  if (typeof document.id !== "string" || document.id.length === 0) {
+    throw new TypeError("Text document ids must be non-empty strings");
+  }
+  if (ids.has(document.id)) {
+    throw new TypeError(`Duplicate text document id: ${document.id}`);
+  }
+  if (typeof document.text !== "string" || document.text.length === 0) {
+    throw new TypeError(`Text document ${document.id} must contain non-empty text`);
+  }
+  ids.add(document.id);
+}
+function chunkDocument(document, chunking) {
+  if (chunking === void 0 || chunking.strategy === "none") {
+    return [createDocumentChunk(document, 0, document.text)];
+  }
+  const textChunks = chunkDocumentText(document.text, chunking);
+  return textChunks.map((chunk) => createDocumentChunk(document, chunk.index, chunk.text));
+}
+function chunkDocumentText(text, chunking) {
+  const overlap = chunking.overlap ?? 0;
+  if (chunking.strategy === "fixed") {
+    return chunkText({
+      text,
+      strategy: "fixed",
+      maxSize: chunking.maxSize,
+      overlap
+    });
+  }
+  return chunkText({
+    text,
+    strategy: "recursive",
+    maxSize: chunking.maxSize,
+    overlap,
+    separators: chunking.separators
+  });
+}
+function createDocumentChunk(document, index, text) {
+  const chunk = {
+    id: `${document.id}:chunk:${index}`,
+    documentId: document.id,
+    index,
+    text
+  };
+  if (document.metadata === void 0) {
+    return chunk;
+  }
+  return { ...chunk, metadata: document.metadata };
+}
+
+export {
+  chunkTextDocuments
+};
+//# sourceMappingURL=chunk-TFIOU6UR.js.map

package/dist/chunk-TFIOU6UR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/documents/text-document.ts"],"sourcesContent":["import { chunkText } from \"./chunk-text\";\n\nexport type TextDocumentMetadata = Record<string, string | number | boolean>;\n\nexport type TextDocument<Metadata = TextDocumentMetadata> = Readonly<{\n  id: string;\n  text: string;\n  metadata?: Metadata | undefined;\n}>;\n\nexport type TextDocumentChunk<Metadata = TextDocumentMetadata> = Readonly<{\n  id: string;\n  documentId: string;\n  index: number;\n  text: string;\n  metadata?: Metadata | undefined;\n}>;\n\nexport type TextDocumentChunkingOptions =\n  | Readonly<{ strategy: \"none\" }>\n  | Readonly<{\n      strategy: \"fixed\";\n      maxSize: number;\n      overlap?: number | undefined;\n    }>\n  | Readonly<{\n      strategy: \"recursive\";\n      maxSize: number;\n      overlap?: number | undefined;\n      separators: readonly string[];\n    }>;\n\nexport type ChunkTextDocumentsOptions<Metadata = TextDocumentMetadata> = Readonly<{\n  documents: readonly TextDocument<Metadata>[];\n  chunking?: TextDocumentChunkingOptions | undefined;\n}>;\n\nexport function chunkTextDocuments<Metadata>(\n  options: ChunkTextDocumentsOptions<Metadata>,\n): readonly TextDocumentChunk<Metadata>[] {\n  if (typeof options !== \"object\" || options === null) {\n    throw new TypeError(\"chunkTextDocuments options must contain a documents array\");\n  }\n  const documents = options.documents;\n  if (!Array.isArray(documents)) {\n    throw new TypeError(\"chunkTextDocuments options must contain a documents array\");\n  }\n\n  const ids = new Set<string>();\n  const chunks: TextDocumentChunk<Metadata>[] = [];\n  for (const document of documents as readonly TextDocument<Metadata>[]) {\n    validateDocument(document, ids);\n    chunks.push(...chunkDocument(document, options.chunking));\n  }\n  return chunks;\n}\n\nfunction validateDocument<Metadata>(document: TextDocument<Metadata>, ids: Set<string>): void {\n  if (typeof document !== \"object\" || document === null) {\n    throw new TypeError(\"Text documents must be objects\");\n  }\n  if (typeof document.id !== \"string\" || document.id.length === 0) {\n    throw new TypeError(\"Text document ids must be non-empty strings\");\n  }\n  if (ids.has(document.id)) {\n    throw new TypeError(`Duplicate text document id: ${document.id}`);\n  }\n  if (typeof document.text !== \"string\" || document.text.length === 0) {\n    throw new TypeError(`Text document ${document.id} must contain non-empty text`);\n  }\n  ids.add(document.id);\n}\n\nfunction chunkDocument<Metadata>(\n  document: TextDocument<Metadata>,\n  chunking: TextDocumentChunkingOptions | undefined,\n): readonly TextDocumentChunk<Metadata>[] {\n  if (chunking === undefined || chunking.strategy === \"none\") {\n    return [createDocumentChunk(document, 0, document.text)];\n  }\n\n  const textChunks = chunkDocumentText(document.text, chunking);\n  return textChunks.map((chunk) => createDocumentChunk(document, chunk.index, chunk.text));\n}\n\nfunction chunkDocumentText(\n  text: string,\n  chunking: Exclude<TextDocumentChunkingOptions, Readonly<{ strategy: \"none\" }>>,\n) {\n  const overlap = chunking.overlap ?? 0;\n  if (chunking.strategy === \"fixed\") {\n    return chunkText({\n      text,\n      strategy: \"fixed\",\n      maxSize: chunking.maxSize,\n      overlap,\n    });\n  }\n  return chunkText({\n    text,\n    strategy: \"recursive\",\n    maxSize: chunking.maxSize,\n    overlap,\n    separators: chunking.separators,\n  });\n}\n\nfunction createDocumentChunk<Metadata>(\n  document: TextDocument<Metadata>,\n  index: number,\n  text: string,\n): TextDocumentChunk<Metadata> {\n  const chunk = {\n    id: `${document.id}:chunk:${index}`,\n    documentId: document.id,\n    index,\n    text,\n  };\n  if (document.metadata === undefined) {\n    return chunk;\n  }\n  return { ...chunk, metadata: document.metadata };\n}\n"],"mappings":";;;;;AAqCO,SAAS,mBACd,SACwC;AACxC,MAAI,OAAO,YAAY,YAAY,YAAY,MAAM;AACnD,UAAM,IAAI,UAAU,2DAA2D;AAAA,EACjF;AACA,QAAM,YAAY,QAAQ;AAC1B,MAAI,CAAC,MAAM,QAAQ,SAAS,GAAG;AAC7B,UAAM,IAAI,UAAU,2DAA2D;AAAA,EACjF;AAEA,QAAM,MAAM,oBAAI,IAAY;AAC5B,QAAM,SAAwC,CAAC;AAC/C,aAAW,YAAY,WAAgD;AACrE,qBAAiB,UAAU,GAAG;AAC9B,WAAO,KAAK,GAAG,cAAc,UAAU,QAAQ,QAAQ,CAAC;AAAA,EAC1D;AACA,SAAO;AACT;AAEA,SAAS,iBAA2B,UAAkC,KAAwB;AAC5F,MAAI,OAAO,aAAa,YAAY,aAAa,MAAM;AACrD,UAAM,IAAI,UAAU,gCAAgC;AAAA,EACtD;AACA,MAAI,OAAO,SAAS,OAAO,YAAY,SAAS,GAAG,WAAW,GAAG;AAC/D,UAAM,IAAI,UAAU,6CAA6C;AAAA,EACnE;AACA,MAAI,IAAI,IAAI,SAAS,EAAE,GAAG;AACxB,UAAM,IAAI,UAAU,+BAA+B,SAAS,EAAE,EAAE;AAAA,EAClE;AACA,MAAI,OAAO,SAAS,SAAS,YAAY,SAAS,KAAK,WAAW,GAAG;AACnE,UAAM,IAAI,UAAU,iBAAiB,SAAS,EAAE,8BAA8B;AAAA,EAChF;AACA,MAAI,IAAI,SAAS,EAAE;AACrB;AAEA,SAAS,cACP,UACA,UACwC;AACxC,MAAI,aAAa,UAAa,SAAS,aAAa,QAAQ;AAC1D,WAAO,CAAC,oBAAoB,UAAU,GAAG,SAAS,IAAI,CAAC;AAAA,EACzD;AAEA,QAAM,aAAa,kBAAkB,SAAS,MAAM,QAAQ;AAC5D,SAAO,WAAW,IAAI,CAAC,UAAU,oBAAoB,UAAU,MAAM,OAAO,MAAM,IAAI,CAAC;AACzF;AAEA,SAAS,kBACP,MACA,UACA;AACA,QAAM,UAAU,SAAS,WAAW;AACpC,MAAI,SAAS,aAAa,SAAS;AACjC,WAAO,UAAU;AAAA,MACf;AAAA,MACA,UAAU;AAAA,MACV,SAAS,SAAS;AAAA,MAClB;AAAA,IACF,CAAC;AAAA,EACH;AACA,SAAO,UAAU;AAAA,IACf;AAAA,IACA,UAAU;AAAA,IACV,SAAS,SAAS;AAAA,IAClB;AAAA,IACA,YAAY,SAAS;AAAA,EACvB,CAAC;AACH;AAEA,SAAS,oBACP,UACA,OACA,MAC6B;AAC7B,QAAM,QAAQ;AAAA,IACZ,IAAI,GAAG,SAAS,EAAE,UAAU,KAAK;AAAA,IACjC,YAAY,SAAS;AAAA,IACrB;AAAA,IACA;AAAA,EACF;AACA,MAAI,SAAS,aAAa,QAAW;AACnC,WAAO;AAAA,EACT;AACA,SAAO,EAAE,GAAG,OAAO,UAAU,SAAS,SAAS;AACjD;","names":[]}

package/dist/chunk-TIZGADU4.js

@@ -0,0 +1,375 @@
+import {
+  snapshotPipelineObservability,
+  startPipelineRunObservers
+} from "./chunk-ETYB5JO6.js";
+import {
+  childContext,
+  combineAbortSignals,
+  pipelineAbortError,
+  runNode,
+  stageContext
+} from "./chunk-EKZRAWBP.js";
+import {
+  PipelineAgentSuspensionError
+} from "./chunk-R6722CIU.js";
+import {
+  appendComposedGraph,
+  appendParallelBranch,
+  appendStageNode,
+  cloneGraph,
+  initialPipelineState,
+  withOutputNode,
+  withTerminalPaths
+} from "./chunk-V3FFZWF3.js";
+import {
+  extract
+} from "./chunk-UOGM62JL.js";
+import {
+  mapWithConcurrency
+} from "./chunk-4FIVU53H.js";
+import {
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
+import {
+  AgentRunBlockedError
+} from "./chunk-WN6AVBO4.js";
+
+// src/pipeline/pipeline.ts
+import { z } from "zod";
+var internalPipelineOptions = /* @__PURE__ */ Symbol("internal-pipeline-options");
+var Pipeline = class {
+  id;
+  name;
+  description;
+  metadata;
+  observability;
+  executor;
+  state;
+  constructor(options) {
+    if (isInternalPipelineOptions(options)) {
+      this.executor = options[internalPipelineOptions].executor;
+      this.state = options[internalPipelineOptions].state;
+      this.observability = options[internalPipelineOptions].observability;
+    } else {
+      const id = normalizePipelineId(options.id);
+      if (!isZodSchema(options.inputSchema)) {
+        throw new TypeError("Pipeline inputSchema must be a Zod schema.");
+      }
+      const inputSchema = options.inputSchema;
+      this.executor = (async (input, context) => {
+        throwIfAborted(context.abortSignal);
+        return inputSchema.parseAsync(input);
+      });
+      this.state = initialPipelineState({
+        id,
+        name: options.name,
+        description: options.description,
+        metadata: options.metadata
+      });
+      this.observability = snapshotPipelineObservability(options.observability);
+    }
+    const graph = this.state.graph;
+    this.id = graph.id;
+    this.name = graph.name;
+    this.description = graph.description;
+    this.metadata = graph.metadata;
+  }
+  step(options) {
+    const next = appendStageNode(this.state, "step", options);
+    const executor = (async (input, context, pathPrefix) => {
+      const value = await this.execute(input, context, pathPrefix);
+      const path = [...pathPrefix, next.node.id];
+      return await runNode(
+        context,
+        next.node,
+        path,
+        value,
+        () => options.run(stageContext(value, context))
+      );
+    });
+    return this.derive(executor, next.state);
+  }
+  compose(options) {
+    const boundary = appendStageNode(this.state, "pipeline", options, {
+      defaultLabel: options.pipeline.name ?? options.pipeline.id,
+      pipelineId: options.pipeline.id
+    });
+    const state = appendComposedGraph(boundary.state, boundary.node, options.pipeline.graph());
+    const executor = (async (input, context, pathPrefix) => {
+      const value = await this.execute(input, context, pathPrefix);
+      const path = [...pathPrefix, boundary.node.id];
+      return await runNode(
+        context,
+        boundary.node,
+        path,
+        value,
+        () => options.pipeline.execute(value, context, path)
+      );
+    });
+    return this.derive(executor, state);
+  }
+  parallel(options) {
+    const branchEntries = normalizeParallelBranches(options.branches);
+    if (branchEntries.length === 0) {
+      throw new TypeError("Pipeline parallel branches must not be empty.");
+    }
+    const parallel = appendStageNode(this.state, "parallel", options, {
+      defaultLabel: `${branchEntries.length} parallel branches`
+    });
+    let nextState = parallel.state;
+    const branchNodes = /* @__PURE__ */ new Map();
+    const terminalPaths = [];
+    for (const [key, branch] of branchEntries) {
+      const appended = appendParallelBranch(nextState, parallel.node, key, branch.graph());
+      nextState = appended.state;
+      branchNodes.set(key, appended.node);
+      terminalPaths.push(...appended.terminalPaths);
+    }
+    nextState = withTerminalPaths(nextState, terminalPaths);
+    return this.derive(async (input, context, pathPrefix) => {
+      const value = await this.execute(input, context, pathPrefix);
+      const parallelPath = [...pathPrefix, parallel.node.id];
+      return runNode(context, parallel.node, parallelPath, value, async () => {
+        const controller = new AbortController();
+        const combined = combineAbortSignals(context.abortSignal, controller.signal);
+        const branchContext = childContext(context, combined.signal);
+        let firstError;
+        const promises = branchEntries.map(async ([key, branch]) => {
+          const node = branchNodes.get(key);
+          const path = [...parallelPath, node.id];
+          try {
+            const output = await runNode(
+              branchContext,
+              node,
+              path,
+              value,
+              () => branch.execute(value, branchContext, path)
+            );
+            return [key, output];
+          } catch (error) {
+            if (firstError === void 0) firstError = error;
+            if (!controller.signal.aborted) controller.abort(error);
+            throw error;
+          }
+        });
+        const settled = await Promise.allSettled(promises);
+        combined.dispose();
+        if (context.abortSignal?.aborted === true) {
+          throw pipelineAbortError(context.abortSignal);
+        }
+        if (firstError !== void 0) throw firstError;
+        return Object.fromEntries(
+          settled.map(
+            (result) => result.value
+          )
+        );
+      });
+    }, nextState);
+  }
+  agent(options) {
+    if (options.suspension !== "reject") {
+      throw new TypeError('Pipeline Agent stages require suspension: "reject".');
+    }
+    const next = appendStageNode(this.state, "agent", options, {
+      defaultLabel: options.agent.name ?? options.agent.id,
+      agentId: options.agent.id,
+      agentName: options.agent.name
+    });
+    return this.derive(async (input, context, pathPrefix) => {
+      const value = await this.execute(input, context, pathPrefix);
+      const path = [...pathPrefix, next.node.id];
+      return runNode(context, next.node, path, value, async (stageTrace) => {
+        const request = await options.request(stageContext(value, context));
+        const response = await options.agent.generate({
+          ...request,
+          trace: withPipelineParentTrace(
+            request.trace,
+            stageTrace,
+            options.agent.observability?.primaryTrace
+          ),
+          abortSignal: context.abortSignal
+        });
+        if (response.type === "interaction") {
+          throw new PipelineAgentSuspensionError(response);
+        }
+        if (response.type === "blocked") {
+          throw new AgentRunBlockedError(response);
+        }
+        return response.output;
+      });
+    }, next.state);
+  }
+  extract(options) {
+    const next = appendStageNode(this.state, "extractor", options);
+    return this.derive(async (input, context, pathPrefix) => {
+      const value = await this.execute(input, context, pathPrefix);
+      const path = [...pathPrefix, next.node.id];
+      return runNode(context, next.node, path, value, async () => {
+        const text = await options.text(stageContext(value, context));
+        const result = await extract({
+          model: options.model,
+          text,
+          outputSchema: options.outputSchema,
+          instructions: options.instructions,
+          retries: options.retries,
+          temperature: options.temperature,
+          maxTokens: options.maxTokens,
+          providerOptions: options.providerOptions,
+          abortSignal: context.abortSignal
+        });
+        return result.output;
+      });
+    }, next.state);
+  }
+  async run(options) {
+    const runId = normalizeRunId(options.runId ?? globalThis.crypto.randomUUID());
+    const startedAt = Date.now();
+    const observability = await startPipelineRunObservers(
+      this.observability?.observers ?? {},
+      {
+        runId,
+        pipelineId: this.id,
+        pipelineName: this.name,
+        pipelineDescription: this.description,
+        pipelineMetadata: this.metadata,
+        runMetadata: options.metadata,
+        trace: options.trace,
+        input: options.input
+      },
+      {
+        primaryTrace: this.observability?.primaryTrace,
+        errorPolicy: this.observability?.errorPolicy ?? "ignore"
+      }
+    );
+    const context = {
+      runId,
+      pipelineId: this.id,
+      runMetadata: options.metadata,
+      abortSignal: options.abortSignal,
+      observer: options.observer,
+      failOnObserverError: options.failOnObserverError === true,
+      observability
+    };
+    try {
+      throwIfAborted(context.abortSignal);
+      const output = await this.execute(options.input, context, []);
+      throwIfAborted(context.abortSignal);
+      await observability.end({
+        runId,
+        pipelineId: this.id,
+        output,
+        durationMs: Date.now() - startedAt
+      });
+      return observability.trace === void 0 ? { runId, output } : { runId, output, trace: observability.trace };
+    } catch (error) {
+      await observability.error({
+        runId,
+        pipelineId: this.id,
+        status: context.abortSignal?.aborted === true ? "cancelled" : "failed",
+        error,
+        durationMs: Date.now() - startedAt
+      });
+      throw error;
+    }
+  }
+  async runBatch(options) {
+    throwIfAborted(options.abortSignal);
+    return mapWithConcurrency([...options.inputs], options.concurrency, async (input) => {
+      const runId = globalThis.crypto.randomUUID();
+      try {
+        const result = await this.run({
+          input,
+          runId,
+          metadata: options.metadata,
+          trace: options.trace,
+          abortSignal: options.abortSignal,
+          observer: options.observer,
+          failOnObserverError: options.failOnObserverError
+        });
+        return { status: "completed", ...result };
+      } catch (error) {
+        if (options.abortSignal?.aborted === true) {
+          throw pipelineAbortError(options.abortSignal);
+        }
+        return { status: "failed", runId, error };
+      }
+    });
+  }
+  graph() {
+    return cloneGraph(withOutputNode(this.state));
+  }
+  derive(executor, state) {
+    return createDerivedPipeline(executor, state, this.observability);
+  }
+  async execute(input, context, pathPrefix) {
+    throwIfAborted(context.abortSignal);
+    return await this.executor(input, context, pathPrefix);
+  }
+};
+function createDerivedPipeline(executor, state, observability) {
+  const options = {
+    [internalPipelineOptions]: { executor, state, observability }
+  };
+  return new Pipeline(options);
+}
+function withPipelineParentTrace(trace, parent, agentPrimaryTrace) {
+  if (parent?.traceId === void 0) return trace;
+  if (parent.observer !== agentPrimaryTrace) return trace;
+  if (trace?.traceId !== void 0 && trace.traceId !== parent.traceId) return trace;
+  return {
+    ...trace,
+    traceId: parent.traceId,
+    ...trace?.parentObservationId !== void 0 || parent.observationId === void 0 ? {} : { parentObservationId: parent.observationId }
+  };
+}
+function isInternalPipelineOptions(options) {
+  return internalPipelineOptions in options;
+}
+function isZodSchema(value) {
+  return value instanceof z.ZodType;
+}
+function normalizePipelineId(id) {
+  if (typeof id !== "string") {
+    throw new TypeError("Pipeline id must be a string.");
+  }
+  const normalized = id.trim();
+  if (normalized.length === 0) {
+    throw new TypeError("Pipeline id must be a non-empty string.");
+  }
+  return normalized;
+}
+function normalizeRunId(runId) {
+  if (typeof runId !== "string") {
+    throw new TypeError("Pipeline runId must be a string.");
+  }
+  const normalized = runId.trim();
+  if (normalized.length === 0) {
+    throw new TypeError("Pipeline runId must be a non-empty string.");
+  }
+  return normalized;
+}
+function normalizeParallelBranches(branches) {
+  const entries = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(branches)) {
+    const pipeline = branches[key];
+    const id = key.trim();
+    if (id.length === 0) {
+      throw new TypeError("Pipeline parallel branch id must be a non-empty string.");
+    }
+    if (ids.has(id)) {
+      throw new TypeError(`Pipeline parallel branch id "${id}" is already registered.`);
+    }
+    ids.add(id);
+    if (id !== key) {
+      throw new TypeError("Pipeline parallel branch ids must not contain surrounding whitespace.");
+    }
+    entries.push([id, pipeline]);
+  }
+  return entries;
+}
+
+export {
+  Pipeline
+};
+//# sourceMappingURL=chunk-TIZGADU4.js.map