@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/agent/index.d.ts

@@ -1,75 +1,71 @@
-import { D as DynamicContextOptions, b as DynamicToolOptions, c as AgentEventStore, d as AgentEventStoreOptions, A as Agent } from '../agent-x3YTyv5i.js';
-export { e as AgentEventAppendInput, f as AgentEventRecord, g as AgentEventStoreInclude, h as AgentSession, i as AgentToolOptions } from '../agent-x3YTyv5i.js';
-import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
-import { C as CompletionModel, P as ProviderTool, l as JsonValue, L as ToolChoice } from '../types-G12i56s2.js';
-import { GuardrailPolicyInput } from '../guardrails/index.js';
-import { P as PromptHook } from '../types-D9JpeAPF.js';
-import { a as McpServer } from '../types-JJCxRnaZ.js';
-import { m as MemoryStore, n as MemoryOptions } from '../types-BrLbKnEz.js';
-import { i as AgentObserver, O as ObserveOptions } from '../index-BxSbmOMr.js';
-import { a as SkillSet } from '../types-04LqWrmy.js';
-import { i as ToolSearchDocument, j as ToolSet, A as AgentMiddleware } from '../middleware-Dp3d_pxi.js';
-import { A as AnyTool, e as ToolApprovalsOptions } from '../tool-Cohdv5GC.js';
-import { a as VectorSearchIndex } from '../types-O-abTIin.js';
+export { M as ModelCallOptions } from '../model-call-options-CZkSw_xN.js';
+export { R as RetryContext, a as RetryOptions, b as RetrySetting } from '../retry-CjvSlKGW.js';
+export { A as Agent, a as AgentContextInput, b as AgentMemory, c as AgentMemoryOptions, d as AgentOptions, e as AgentToolInput, f as AgentToolOptions, C as CreateHybridVectorContextOptions, g as CreateVectorContextOptions, V as VectorContext, h as VectorContextBaseOptions, i as createVectorContext, j as isVectorContext } from '../agent-DWzW9SoH.js';
+import { M as Message, U as Usage, C as CompletionFinishReason } from '../types-DgvozfPc.js';
+import { A as AgentBlockedResult, t as AgentSuspendedResult } from '../types-Sue2hb_L.js';
+export { a as AgentChildStreamEvent, b as AgentDeltaEvent, c as AgentErrorEvent, d as AgentErrorStreamEvent, e as AgentFinishEvent, f as AgentInput, g as AgentLifecycle, h as AgentMemoryCompactionEvent, i as AgentPrompt, j as AgentResponse, k as AgentResult, l as AgentRunOptions, m as AgentRunSettings, n as AgentStartEvent, o as AgentSteerInput, p as AgentSteerReceipt, q as AgentStepFinishEvent, r as AgentStream, s as AgentStreamEvent, u as AgentToolCallDeltaEvent, v as AgentToolFinishEvent, w as AgentToolStartEvent } from '../types-Sue2hb_L.js';
+import '../zod-schema-C7F4clpm.js';
 import 'zod';
-import '@modelcontextprotocol/sdk/client/sse.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import '../types-BCTRUGex.js';
+import '../types-DhkodEft.js';
+import '../type-utils-CtHVDRn_.js';
+import '../types-DjqRHeAi.js';
+import '../tool-BpqpoRSE.js';
+import '../middleware-kcF8AusP.js';
+import '../types-DKOXVTcq.js';
+import '../types-DC1U1XwW.js';
+import '../dynamic-tools-aIZlg5x1.js';
+import '../types-Cr4uiYo5.js';
+import '../types-CXNE592e.js';
+import './interactions/index.js';
 
-declare class AgentBuilder<M extends CompletionModel = CompletionModel> {
-    private readonly completionModel;
-    private readonly agentId;
-    private agentName;
-    private agentDescription;
-    private instructionBlocks;
-    private contextDocs;
-    private temp;
-    private maxTokenCount;
-    private params;
-    private choice;
-    private turns;
-    private requestHook;
-    private schema;
-    private approvalOptions;
-    private guardrailPolicies;
-    private skillInstructionBlocks;
-    private observerRegistrations;
-    private dynamicContextRegistrations;
-    private dynamicToolRegistrations;
-    private middlewareRegistrations;
-    private memoryRegistration;
-    private eventStoreRegistration;
-    private activeToolSet;
-    private providerToolDefs;
-    constructor(agentId: string, completionModel: M);
-    name(name: string): this;
-    description(description: string): this;
-    instructions(instructions: string): this;
-    context(text: string, id?: string): this;
-    dynamicContext<T>(index: VectorSearchIndex<T>, options: DynamicContextOptions<T>): this;
-    dynamicTools(index: VectorSearchIndex<ToolSearchDocument>, options: DynamicToolOptions): this;
-    tool(tool: AnyTool | ProviderTool): this;
-    tools(tools: Array<AnyTool | ProviderTool>): this;
-    mcp(servers: McpServer[]): this;
-    skills(skillSet: SkillSet): this;
-    useToolSet(toolSet: ToolSet): this;
-    temperature(temperature: number): this;
-    maxTokens(maxTokens: number): this;
-    additionalParams(params: JsonValue): this;
-    toolChoice(toolChoice: ToolChoice): this;
-    defaultMaxTurns(defaultMaxTurns: number): this;
-    hook(hook: PromptHook): this;
-    middleware(middleware: AgentMiddleware): this;
-    middlewares(middlewares: AgentMiddleware[]): this;
-    observe(observer: AgentObserver, options?: ObserveOptions): this;
-    approvals(options: ToolApprovalsOptions): this;
-    guardrails(policies: GuardrailPolicyInput): this;
-    memory(store: MemoryStore, options?: MemoryOptions): this;
-    eventStore(store: AgentEventStore, options?: AgentEventStoreOptions): this;
-    outputSchema(schema: ZodSchema): this;
-    build(): Agent<M>;
-    private buildInstructions;
+type AgentStructuredOutputPhase = "truncated" | "content-filter" | "parse" | "schema";
+type AgentStructuredOutputFormat = "raw" | "json-fence" | "unlabeled-fence";
+declare class AgentStructuredOutputError extends Error {
+    readonly phase: AgentStructuredOutputPhase;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    readonly outputLength: number;
+    readonly normalizedLength: number;
+    readonly outputFormat: AgentStructuredOutputFormat;
+    readonly attemptUsage: Usage;
+    readonly usage: Usage;
+    readonly finishReason: CompletionFinishReason | undefined;
+    readonly providerFinishReason: string | undefined;
+    constructor(options: {
+        phase: AgentStructuredOutputPhase;
+        attempt: number;
+        maxAttempts: number;
+        outputLength: number;
+        normalizedLength: number;
+        outputFormat: AgentStructuredOutputFormat;
+        attemptUsage: Usage;
+        usage: Usage;
+        finishReason?: CompletionFinishReason | undefined;
+        providerFinishReason?: string | undefined;
+        cause?: unknown;
+    });
+}
+declare class MaxTurnsError extends Error {
+    readonly maxTurns: number;
+    readonly chatHistory: Message[];
+    readonly prompt: Message;
+    constructor(maxTurns: number, chatHistory: Message[], prompt: Message);
+}
+declare class AgentRunCancelledError extends Error {
+    readonly chatHistory: Message[];
+    readonly reason: string;
+    constructor(chatHistory: Message[], reason: string, options?: ErrorOptions);
+}
+declare class AgentRunBlockedError extends Error {
+    readonly result: AgentBlockedResult;
+    constructor(result: AgentBlockedResult);
+}
+declare class AgentStreamClosedError extends Error {
+    constructor();
+}
+declare class AgentToolSuspensionError extends Error {
+    readonly result: AgentSuspendedResult;
+    constructor(result: AgentSuspendedResult);
 }
 
-export { Agent, AgentBuilder, AgentEventStore, AgentEventStoreOptions, DynamicContextOptions, DynamicToolOptions };
+export { AgentBlockedResult, AgentRunBlockedError, AgentRunCancelledError, AgentStreamClosedError, AgentStructuredOutputError, type AgentStructuredOutputFormat, type AgentStructuredOutputPhase, AgentSuspendedResult, AgentToolSuspensionError, MaxTurnsError };

package/dist/agent/index.js

@@ -1,23 +1,41 @@
 import {
-  AgentBuilder
-} from "../chunk-JI5YZWNT.js";
-import "../chunk-DALYP4PX.js";
-import "../chunk-BALBBVI3.js";
+  Agent,
+  createVectorContext,
+  isVectorContext
+} from "../chunk-VX3HS6PE.js";
+import "../chunk-OJBFDBLG.js";
+import "../chunk-J6LVLV6P.js";
+import "../chunk-5C6B6ZRH.js";
+import "../chunk-6BBOCFHV.js";
 import "../chunk-YK4WAAS4.js";
-import "../chunk-XUUY2L2D.js";
-import "../chunk-HYUYZEAJ.js";
-import "../chunk-MELYDKWQ.js";
-import "../chunk-2ODTMRHP.js";
-import "../chunk-UQX6EXWG.js";
-import "../chunk-MRQLEK2B.js";
-import "../chunk-MNWK2USR.js";
-import "../chunk-OIMLU4SF.js";
-import "../chunk-Q25IWLBT.js";
-import "../chunk-MC3CCKEB.js";
-import "../chunk-ADH7NNCS.js";
-import "../chunk-WQKHFADH.js";
-import "../chunk-CWUJUSOS.js";
+import "../chunk-SJMSS5SI.js";
+import "../chunk-EMZKPRE6.js";
+import {
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentStructuredOutputError,
+  AgentToolSuspensionError,
+  MaxTurnsError
+} from "../chunk-X4LK4ODN.js";
+import "../chunk-ZA564323.js";
+import "../chunk-3RM57ZT2.js";
+import "../chunk-D4PACGPA.js";
+import "../chunk-7PHMK7W4.js";
+import "../chunk-7JLAIN6E.js";
+import "../chunk-QGX73TSQ.js";
+import "../chunk-3XQGVDU5.js";
+import "../chunk-3RWESPUG.js";
+import "../chunk-AZB6N7P4.js";
 export {
-  AgentBuilder
+  Agent,
+  AgentRunBlockedError,
+  AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentStructuredOutputError,
+  AgentToolSuspensionError,
+  MaxTurnsError,
+  createVectorContext,
+  isVectorContext
 };
 //# sourceMappingURL=index.js.map

package/dist/agent/interactions/index.d.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { p as JsonValue, J as JsonObject, $ as ToolQuestionAnswer } from '../../types-DgvozfPc.js';
+import '../../model-call-options-CZkSw_xN.js';
+
+type AgentQuestionChoice = Readonly<{
+    label: string;
+    value: string;
+}>;
+type AgentQuestionPrompt = Readonly<{
+    id: string;
+    text: string;
+    choices?: readonly AgentQuestionChoice[];
+    allowCustom?: boolean;
+}>;
+type AgentQuestionAnswer = ToolQuestionAnswer;
+type AgentInteractionRequestBase = Readonly<{
+    id: string;
+    toolName: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId: string;
+}>;
+type AgentToolApprovalRequest = AgentInteractionRequestBase & Readonly<{
+    type: "tool-approval";
+    input: JsonValue;
+    reason?: string;
+}>;
+type AgentToolQuestionRequest = AgentInteractionRequestBase & Readonly<{
+    type: "tool-question";
+    questions: readonly AgentQuestionPrompt[];
+}>;
+type AgentInteractionRequest = AgentToolApprovalRequest | AgentToolQuestionRequest;
+type AgentInteractionResponse = Readonly<{
+    type: "tool-approval";
+    approved: boolean;
+    reason?: string;
+}> | Readonly<{
+    type: "tool-question";
+    answers: readonly AgentQuestionAnswer[];
+}>;
+type AgentContinuation = Readonly<{
+    version: 1;
+    agentId: string;
+    sourceRunId: string;
+    interaction: AgentInteractionRequest;
+    state: JsonObject;
+}>;
+declare const agentInteractionRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    input: z.ZodCustom<JsonValue, JsonValue>;
+    reason: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    internalCallId: z.ZodString;
+    type: z.ZodLiteral<"tool-approval">;
+}, z.core.$strict>, z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>>;
+        allowCustom: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+    callId: z.ZodOptional<z.ZodString>;
+    internalCallId: z.ZodString;
+    type: z.ZodLiteral<"tool-question">;
+}, z.core.$strict>], "type">;
+declare const agentInteractionResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"tool-approval">;
+    approved: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tool-question">;
+    answers: z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "type">;
+declare const agentContinuationSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    agentId: z.ZodString;
+    sourceRunId: z.ZodString;
+    interaction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        input: z.ZodCustom<JsonValue, JsonValue>;
+        reason: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        toolName: z.ZodString;
+        toolCallId: z.ZodString;
+        callId: z.ZodOptional<z.ZodString>;
+        internalCallId: z.ZodString;
+        type: z.ZodLiteral<"tool-approval">;
+    }, z.core.$strict>, z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>>;
+            allowCustom: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        toolName: z.ZodString;
+        toolCallId: z.ZodString;
+        callId: z.ZodOptional<z.ZodString>;
+        internalCallId: z.ZodString;
+        type: z.ZodLiteral<"tool-question">;
+    }, z.core.$strict>], "type">;
+    state: z.ZodCustom<JsonObject, JsonObject>;
+}, z.core.$strict>;
+declare function parseAgentInteractionRequest(value: unknown): AgentInteractionRequest;
+declare function parseAgentInteractionResponse(value: unknown): AgentInteractionResponse;
+declare function parseAgentContinuation(value: unknown): AgentContinuation;
+declare function assertAgentInteractionResponse(request: AgentInteractionRequest, response: AgentInteractionResponse): void;
+
+export { type AgentContinuation, type AgentInteractionRequest, type AgentInteractionResponse, type AgentQuestionAnswer, type AgentQuestionChoice, type AgentQuestionPrompt, type AgentToolApprovalRequest, type AgentToolQuestionRequest, agentContinuationSchema, agentInteractionRequestSchema, agentInteractionResponseSchema, assertAgentInteractionResponse, parseAgentContinuation, parseAgentInteractionRequest, parseAgentInteractionResponse };

package/dist/agent/interactions/index.js

@@ -0,0 +1,20 @@
+import {
+  agentContinuationSchema,
+  agentInteractionRequestSchema,
+  agentInteractionResponseSchema,
+  assertAgentInteractionResponse,
+  parseAgentContinuation,
+  parseAgentInteractionRequest,
+  parseAgentInteractionResponse
+} from "../../chunk-OJBFDBLG.js";
+import "../../chunk-3XQGVDU5.js";
+export {
+  agentContinuationSchema,
+  agentInteractionRequestSchema,
+  agentInteractionResponseSchema,
+  assertAgentInteractionResponse,
+  parseAgentContinuation,
+  parseAgentInteractionRequest,
+  parseAgentInteractionResponse
+};
+//# sourceMappingURL=index.js.map

package/dist/agent-DWzW9SoH.d.ts

@@ -0,0 +1,150 @@
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { D as Document, c as CompletionModel, P as ProviderTool, J as JsonObject, v as ToolChoice } from './types-DgvozfPc.js';
+import { Z as ZodSchema } from './zod-schema-C7F4clpm.js';
+import { d as GuardrailPolicyInput, c as GuardrailPolicy } from './types-DhkodEft.js';
+import { a as McpServer } from './types-DjqRHeAi.js';
+import { g as AgentLifecycle, E as AgentObservabilityOptions, l as AgentRunOptions, k as AgentResult, r as AgentStream, s as AgentStreamEvent } from './types-Sue2hb_L.js';
+import { A as AgentMiddleware } from './middleware-kcF8AusP.js';
+import { A as AnyTool, T as Tool, c as ToolCallContext, N as NormalizedToolOutput } from './tool-BpqpoRSE.js';
+import { D as MemoryStore, y as MemorySavePolicy, m as MemoryCompactor, d as MemoryCompactionConflictRetryOptions, x as MemoryOptions } from './types-DKOXVTcq.js';
+import { a as SkillSet } from './types-DC1U1XwW.js';
+import { T as ToolIndex } from './dynamic-tools-aIZlg5x1.js';
+import { E as EmbeddingModel, c as SparseEmbeddingModel } from './types-Cr4uiYo5.js';
+import { V as VectorFilter, a as VectorSearchResult, d as VectorStore, H as HybridVectorStore, e as VectorFusion } from './types-CXNE592e.js';
+
+type VectorContextBaseOptions<T = unknown> = {
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+    format?(result: VectorSearchResult<T>): Document;
+};
+type CreateVectorContextOptions<T = unknown> = VectorContextBaseOptions<T> & {
+    store: VectorStore<T>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type CreateHybridVectorContextOptions<T = unknown> = VectorContextBaseOptions<T> & {
+    store: HybridVectorStore<T>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorContext<T = unknown> = (CreateVectorContextOptions<T> | CreateHybridVectorContextOptions<T>) & {
+    readonly kind: "vector-context";
+};
+declare function createVectorContext<T>(options: CreateVectorContextOptions<T>): VectorContext<T>;
+declare function createVectorContext<T>(options: CreateHybridVectorContextOptions<T>): VectorContext<T>;
+declare function isVectorContext(value: unknown): value is VectorContext;
+
+type AgentToolInput = AnyTool | ProviderTool | ToolIndex;
+type AgentContextInput<T = unknown> = Document | VectorContext<T>;
+type RawResponseOf$1<Model> = Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;
+type AgentOptions<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown> = {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    model: M;
+    instructions?: string | undefined;
+    context?: readonly AgentContextInput<ContextDocument>[] | undefined;
+    tools?: readonly AgentToolInput[] | undefined;
+    mcpServers?: readonly McpServer[] | undefined;
+    skills?: SkillSet | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+    toolChoice?: ToolChoice | undefined;
+    maxTurns?: number | undefined;
+    lifecycle?: AgentLifecycle<Output, RawResponseOf$1<M>> | undefined;
+    outputSchema?: ZodSchema<Output> | undefined;
+    observability?: AgentObservabilityOptions | undefined;
+    guardrails?: GuardrailPolicyInput | undefined;
+    middlewares?: readonly AgentMiddleware[] | undefined;
+    memory?: AgentMemoryOptions | undefined;
+};
+type AgentMemoryOptions = MemoryOptions & {
+    store: MemoryStore;
+};
+type AgentMemory = {
+    store: MemoryStore;
+    savePolicy: MemorySavePolicy;
+    compaction?: {
+        trigger: {
+            afterMessages: number;
+        };
+        retention: {
+            recentUserTurns: number;
+        };
+        compactor: MemoryCompactor;
+        conflictRetries: false | MemoryCompactionConflictRetryOptions;
+    } | undefined;
+};
+type ResolvedAgentOptions<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown> = {
+    id: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    model: M;
+    instructions?: string | undefined;
+    context?: readonly AgentContextInput<ContextDocument>[] | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+    tools?: readonly AnyTool[] | undefined;
+    mcpServers?: readonly McpServer[] | undefined;
+    providerTools?: readonly ProviderTool[] | undefined;
+    toolIndexes?: readonly ToolIndex[] | undefined;
+    toolChoice?: ToolChoice | undefined;
+    defaultMaxTurns?: number | undefined;
+    lifecycle?: AgentLifecycle<Output, RawResponseOf$1<M>> | undefined;
+    outputSchema?: ZodSchema<Output> | undefined;
+    observability?: AgentObservabilityOptions | undefined;
+    guardrails?: readonly GuardrailPolicy[] | undefined;
+    middlewares?: readonly AgentMiddleware[] | undefined;
+    memory?: AgentMemory | undefined;
+};
+type AgentToolOptions = {
+    name: string;
+    suspension: "reject";
+    description?: string | undefined;
+    maxTurns?: number | undefined;
+    stream?: boolean | undefined;
+};
+
+type RawResponseOf<Model> = Model extends CompletionModel<infer RawResponse> ? RawResponse : unknown;
+declare class Agent<Output = string, M extends CompletionModel = CompletionModel, ContextDocument = unknown> {
+    readonly id: string;
+    readonly name: string | undefined;
+    readonly description: string | undefined;
+    readonly model: M;
+    readonly instructions: string | undefined;
+    readonly context: readonly AgentContextInput<ContextDocument>[];
+    readonly temperature: number | undefined;
+    readonly maxTokens: number | undefined;
+    readonly providerOptions: JsonObject | undefined;
+    readonly retries: RetrySetting | undefined;
+    readonly mcpServers: readonly McpServer[];
+    readonly tools: readonly AnyTool[];
+    readonly toolChoice: ToolChoice | undefined;
+    readonly defaultMaxTurns: number | undefined;
+    readonly lifecycle: AgentLifecycle<Output, RawResponseOf<M>> | undefined;
+    readonly outputSchema: ZodSchema<Output> | undefined;
+    readonly observability: AgentObservabilityOptions | undefined;
+    readonly guardrails: readonly GuardrailPolicy[];
+    readonly middlewares: readonly AgentMiddleware[];
+    readonly memory: AgentMemory | undefined;
+    constructor(options: AgentOptions<Output, M, ContextDocument>);
+    generate(options: AgentRunOptions<Output, RawResponseOf<M>>): Promise<AgentResult<Output>>;
+    stream(options: AgentRunOptions<Output, RawResponseOf<M>>): AgentStream<AgentStreamEvent<Output, RawResponseOf<M>>>;
+    asTool(options: AgentToolOptions): Tool<{
+        prompt: string;
+    }, Output>;
+    getTool(toolName: string): AnyTool | undefined;
+    callTool(toolName: string, args: string, context?: ToolCallContext): Promise<NormalizedToolOutput>;
+}
+
+export { Agent as A, type CreateHybridVectorContextOptions as C, type ResolvedAgentOptions as R, type VectorContext as V, type AgentContextInput as a, type AgentMemory as b, type AgentMemoryOptions as c, type AgentOptions as d, type AgentToolInput as e, type AgentToolOptions as f, type CreateVectorContextOptions as g, type VectorContextBaseOptions as h, createVectorContext as i, isVectorContext as j };

package/dist/chunk-3RM57ZT2.js

@@ -0,0 +1,31 @@
+// src/internal/concurrency.ts
+async function mapWithConcurrency(inputs, concurrency, mapper) {
+  if (!Number.isSafeInteger(concurrency) || concurrency <= 0) {
+    throw new RangeError("concurrency must be a positive safe integer.");
+  }
+  const limit = concurrency;
+  const results = new Array(inputs.length);
+  let nextIndex = 0;
+  let firstFailure;
+  async function worker() {
+    while (firstFailure === void 0 && nextIndex < inputs.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      try {
+        results[index] = await mapper(inputs[index]);
+      } catch (error) {
+        firstFailure ??= { error };
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, inputs.length) }, () => worker()));
+  if (firstFailure !== void 0) {
+    throw firstFailure.error;
+  }
+  return results;
+}
+
+export {
+  mapWithConcurrency
+};
+//# sourceMappingURL=chunk-3RM57ZT2.js.map

package/dist/chunk-3RM57ZT2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/concurrency.ts"],"sourcesContent":["export async function mapWithConcurrency<Input, Output>(\n  inputs: readonly Input[],\n  concurrency: number,\n  mapper: (input: Input) => Promise<Output>,\n): Promise<Output[]> {\n  if (!Number.isSafeInteger(concurrency) || concurrency <= 0) {\n    throw new RangeError(\"concurrency must be a positive safe integer.\");\n  }\n  const limit = concurrency;\n  const results = new Array<Output>(inputs.length);\n  let nextIndex = 0;\n  let firstFailure: { error: unknown } | undefined;\n\n  async function worker(): Promise<void> {\n    while (firstFailure === undefined && nextIndex < inputs.length) {\n      const index = nextIndex;\n      nextIndex += 1;\n      try {\n        results[index] = await mapper(inputs[index] as Input);\n      } catch (error) {\n        firstFailure ??= { error };\n      }\n    }\n  }\n\n  await Promise.all(Array.from({ length: Math.min(limit, inputs.length) }, () => worker()));\n  if (firstFailure !== undefined) {\n    throw firstFailure.error;\n  }\n  return results;\n}\n"],"mappings":";AAAA,eAAsB,mBACpB,QACA,aACA,QACmB;AACnB,MAAI,CAAC,OAAO,cAAc,WAAW,KAAK,eAAe,GAAG;AAC1D,UAAM,IAAI,WAAW,8CAA8C;AAAA,EACrE;AACA,QAAM,QAAQ;AACd,QAAM,UAAU,IAAI,MAAc,OAAO,MAAM;AAC/C,MAAI,YAAY;AAChB,MAAI;AAEJ,iBAAe,SAAwB;AACrC,WAAO,iBAAiB,UAAa,YAAY,OAAO,QAAQ;AAC9D,YAAM,QAAQ;AACd,mBAAa;AACb,UAAI;AACF,gBAAQ,KAAK,IAAI,MAAM,OAAO,OAAO,KAAK,CAAU;AAAA,MACtD,SAAS,OAAO;AACd,yBAAiB,EAAE,MAAM;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAEA,QAAM,QAAQ,IAAI,MAAM,KAAK,EAAE,QAAQ,KAAK,IAAI,OAAO,OAAO,MAAM,EAAE,GAAG,MAAM,OAAO,CAAC,CAAC;AACxF,MAAI,iBAAiB,QAAW;AAC9B,UAAM,aAAa;AAAA,EACrB;AACA,SAAO;AACT;","names":[]}