@anvia/core 0.26.0 → 1.0.0-rc.1

package/dist/extractor/index.d.ts

@@ -1,17 +1,20 @@
-import { A as Agent } from '../agent-x3YTyv5i.js';
+import { a as RetryOptions } from '../retry-D3Ruy-ba.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
-import { U as Usage, M as Message, C as CompletionModel, l as JsonValue, L as ToolChoice } from '../types-G12i56s2.js';
-import '../guardrails/index.js';
-import '../types-D9JpeAPF.js';
-import '../types-BrLbKnEz.js';
-import '../index-BxSbmOMr.js';
-import '../tool-Cohdv5GC.js';
-import '../middleware-Dp3d_pxi.js';
-import '../types-BCTRUGex.js';
-import '../types-O-abTIin.js';
+import { l as JsonValue, U as Usage, M as Message, C as CompletionModel } from '../types-B3A4YxaA.js';
 import 'zod';
 
-type ExtractionResponse<T> = {
+type ExtractorOptions<T, M extends CompletionModel = CompletionModel> = {
+    model: M;
+    outputSchema: ZodSchema<T>;
+    instructions?: string | undefined;
+};
+type ExtractOptions = {
+    retries?: RetryOptions | undefined;
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    additionalParams?: JsonValue | undefined;
+};
+type ExtractionResult<T> = {
     data: T;
     usage: Usage;
     messages: Message[];
@@ -20,30 +23,15 @@ declare class ExtractionError extends Error {
     readonly cause?: unknown | undefined;
     constructor(message: string, cause?: unknown | undefined);
 }
+/** Converts text into data validated and transformed by a Zod output schema. */
 declare class Extractor<T, M extends CompletionModel = CompletionModel> {
-    private readonly agent;
-    private readonly schema;
-    private readonly retryCount;
-    constructor(agent: Agent<M>, schema: ZodSchema<T>, retryCount: number);
-    extract(text: string | Message): Promise<T>;
-    extractWithUsage(text: string | Message): Promise<ExtractionResponse<T>>;
-    extractWithHistory(text: string | Message, history: Message[]): Promise<T>;
-    getInner(): Agent<M>;
-    private run;
-}
-declare class ExtractorBuilder<T, M extends CompletionModel = CompletionModel> {
-    private readonly schema;
-    private readonly agentBuilder;
-    private retryCount;
-    constructor(model: M, schema: ZodSchema<T>);
-    instructions(instructions: string): this;
-    context(text: string, id?: string): this;
-    temperature(temperature: number): this;
-    maxTokens(maxTokens: number): this;
-    additionalParams(params: JsonValue): this;
-    toolChoice(toolChoice: ToolChoice): this;
-    retries(retries: number): this;
-    build(): Extractor<T, M>;
+    readonly model: M;
+    readonly outputSchema: ZodSchema<T>;
+    private readonly instructions;
+    private readonly submitTool;
+    constructor(options: ExtractorOptions<T, M>);
+    extract(text: string, options?: ExtractOptions): Promise<T>;
+    extractResult(text: string, options?: ExtractOptions): Promise<ExtractionResult<T>>;
 }
 
-export { ExtractionError, type ExtractionResponse, Extractor, ExtractorBuilder };
+export { type ExtractOptions, ExtractionError, type ExtractionResult, Extractor, type ExtractorOptions };

package/dist/extractor/index.js

@@ -1,28 +1,14 @@
 import {
   ExtractionError,
-  Extractor,
-  ExtractorBuilder
-} from "../chunk-YLMDBQO4.js";
-import "../chunk-JI5YZWNT.js";
-import "../chunk-DALYP4PX.js";
-import "../chunk-BALBBVI3.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";
+  Extractor
+} from "../chunk-J6GNQART.js";
+import "../chunk-I6G7BC42.js";
+import "../chunk-M3IOWB4Y.js";
+import "../chunk-RFDVKCIE.js";
 import "../chunk-ADH7NNCS.js";
-import "../chunk-WQKHFADH.js";
-import "../chunk-CWUJUSOS.js";
+import "../chunk-A3UBYTJT.js";
 export {
   ExtractionError,
-  Extractor,
-  ExtractorBuilder
+  Extractor
 };
 //# sourceMappingURL=index.js.map

package/dist/guardrails/index.d.ts

@@ -1,6 +1,6 @@
-import { M as Message, J as JsonObject, U as Usage } from '../types-G12i56s2.js';
+import { M as Message, J as JsonObject, U as Usage } from '../types-B3A4YxaA.js';
+import { M as MaybePromise } from '../type-utils-CtHVDRn_.js';
 
-type MaybePromise<T> = T | Promise<T>;
 type GuardrailMode = "enforce" | "observe";
 type GuardrailBoundary = "input" | "output";
 type GuardrailRunContext = {

package/dist/guardrails/index.js

@@ -10,7 +10,7 @@ import {
   normalizeGuardrailPolicies,
   runInputGuardrails,
   runOutputGuardrails
-} from "../chunk-CWUJUSOS.js";
+} from "../chunk-FNQB2JEH.js";
 export {
   allow,
   appendGuardrailPolicies,

package/dist/image-generation/index.d.ts

@@ -1,4 +1,6 @@
-import { l as JsonValue } from '../types-G12i56s2.js';
+import { a as RetryOptions } from '../retry-D3Ruy-ba.js';
+export { R as RetryContext } from '../retry-D3Ruy-ba.js';
+import { l as JsonValue } from '../types-B3A4YxaA.js';
 
 type ImageGenerationRequest = {
     prompt: string;
@@ -22,17 +24,13 @@ interface ImageGenerationModel<RawResponse = unknown, ModelName extends string =
     imageGeneration(request: ImageGenerationRequest): Promise<ImageGenerationResponse<RawResponse>>;
 }
 
-declare class ImageGenerationRequestBuilder<Model extends ImageGenerationModel = ImageGenerationModel> {
-    private readonly model;
-    private request;
-    constructor(model: Model);
-    prompt(prompt: string): this;
-    width(width: number): this;
-    height(height: number): this;
-    additionalParams(additionalParams: JsonValue): this;
-    build(): ImageGenerationRequest;
-    send(): Promise<Awaited<ReturnType<Model["imageGeneration"]>>>;
-}
-declare function imageGenerationRequest<Model extends ImageGenerationModel>(model: Model): ImageGenerationRequestBuilder<Model>;
+type GenerateImageOptions<Model extends ImageGenerationModel = ImageGenerationModel> = {
+    model: Model;
+    width?: number | undefined;
+    height?: number | undefined;
+    additionalParams?: JsonValue | undefined;
+    retries?: RetryOptions | undefined;
+};
+declare function generateImage<Model extends ImageGenerationModel>(prompt: string, options: GenerateImageOptions<Model>): Promise<Awaited<ReturnType<Model["imageGeneration"]>>>;
 
-export { type GeneratedImage, type ImageGenerationModel, type ImageGenerationRequest, ImageGenerationRequestBuilder, type ImageGenerationResponse, imageGenerationRequest };
+export { type GenerateImageOptions, type GeneratedImage, type ImageGenerationModel, type ImageGenerationRequest, type ImageGenerationResponse, RetryOptions, generateImage };

package/dist/image-generation/index.js

@@ -1,42 +1,8 @@
-// src/image-generation/request.ts
-var ImageGenerationRequestBuilder = class {
-  constructor(model) {
-    this.model = model;
-  }
-  model;
-  request = {
-    prompt: "",
-    width: 1024,
-    height: 1024
-  };
-  prompt(prompt) {
-    this.request = { ...this.request, prompt };
-    return this;
-  }
-  width(width) {
-    this.request = { ...this.request, width };
-    return this;
-  }
-  height(height) {
-    this.request = { ...this.request, height };
-    return this;
-  }
-  additionalParams(additionalParams) {
-    this.request = { ...this.request, additionalParams };
-    return this;
-  }
-  build() {
-    return { ...this.request };
-  }
-  send() {
-    return this.model.imageGeneration(this.build());
-  }
-};
-function imageGenerationRequest(model) {
-  return new ImageGenerationRequestBuilder(model);
-}
+import {
+  generateImage
+} from "../chunk-XDRSPSR7.js";
+import "../chunk-A3UBYTJT.js";
 export {
-  ImageGenerationRequestBuilder,
-  imageGenerationRequest
+  generateImage
 };
 //# sourceMappingURL=index.js.map

package/dist/image-generation/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/image-generation/request.ts"],"sourcesContent":["import type { JsonValue } from \"../completion/types\";\nimport type { ImageGenerationModel, ImageGenerationRequest } from \"./types\";\n\nexport class ImageGenerationRequestBuilder<\n  Model extends ImageGenerationModel = ImageGenerationModel,\n> {\n  private request: ImageGenerationRequest = {\n    prompt: \"\",\n    width: 1024,\n    height: 1024,\n  };\n\n  constructor(private readonly model: Model) {}\n\n  prompt(prompt: string): this {\n    this.request = { ...this.request, prompt };\n    return this;\n  }\n\n  width(width: number): this {\n    this.request = { ...this.request, width };\n    return this;\n  }\n\n  height(height: number): this {\n    this.request = { ...this.request, height };\n    return this;\n  }\n\n  additionalParams(additionalParams: JsonValue): this {\n    this.request = { ...this.request, additionalParams };\n    return this;\n  }\n\n  build(): ImageGenerationRequest {\n    return { ...this.request };\n  }\n\n  send(): Promise<Awaited<ReturnType<Model[\"imageGeneration\"]>>> {\n    return this.model.imageGeneration(this.build()) as Promise<\n      Awaited<ReturnType<Model[\"imageGeneration\"]>>\n    >;\n  }\n}\n\nexport function imageGenerationRequest<Model extends ImageGenerationModel>(\n  model: Model,\n): ImageGenerationRequestBuilder<Model> {\n  return new ImageGenerationRequestBuilder(model);\n}\n"],"mappings":";AAGO,IAAM,gCAAN,MAEL;AAAA,EAOA,YAA6B,OAAc;AAAd;AAAA,EAAe;AAAA,EAAf;AAAA,EANrB,UAAkC;AAAA,IACxC,QAAQ;AAAA,IACR,OAAO;AAAA,IACP,QAAQ;AAAA,EACV;AAAA,EAIA,OAAO,QAAsB;AAC3B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,OAAO;AACzC,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,OAAqB;AACzB,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,MAAM;AACxC,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,QAAsB;AAC3B,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,OAAO;AACzC,WAAO;AAAA,EACT;AAAA,EAEA,iBAAiB,kBAAmC;AAClD,SAAK,UAAU,EAAE,GAAG,KAAK,SAAS,iBAAiB;AACnD,WAAO;AAAA,EACT;AAAA,EAEA,QAAgC;AAC9B,WAAO,EAAE,GAAG,KAAK,QAAQ;AAAA,EAC3B;AAAA,EAEA,OAA+D;AAC7D,WAAO,KAAK,MAAM,gBAAgB,KAAK,MAAM,CAAC;AAAA,EAGhD;AACF;AAEO,SAAS,uBACd,OACsC;AACtC,SAAO,IAAI,8BAA8B,KAAK;AAChD;","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-DxB74ybJ.d.ts

@@ -0,0 +1,349 @@
+import { a as RetryOptions } from './retry-D3Ruy-ba.js';
+import { M as Message, g as CompletionResponse, U as Usage, V as ReasoningContentType, p as ToolCall, h as CompletionSource, o as ProviderToolCall, j as ContextUsage, f as CompletionRequest, u as ToolResultContent, X as ToolCallArgumentsMode, J as JsonObject, K as CompletionModelCapabilities, r as ToolDefinition, l as JsonValue } from './types-B3A4YxaA.js';
+import { GuardrailPolicyInput, GuardrailDecisionRecord } from './guardrails/index.js';
+import { A as AgentMiddleware } from './middleware-KynLg_RW.js';
+import { D as DeepReadonly, M as MaybePromise } from './type-utils-CtHVDRn_.js';
+import { d as ToolCallStreamEvent } from './tool-C_8GudXn.js';
+
+type AgentLifecycleRunEvent = {
+    runId: string;
+};
+type AgentStartEvent = AgentLifecycleRunEvent & {
+    input: DeepReadonly<Message>;
+    history: DeepReadonly<Message[]>;
+    maxTurns: number;
+};
+type AgentStepFinishEvent<RawResponse = unknown> = AgentLifecycleRunEvent & {
+    step: number;
+    response: DeepReadonly<CompletionResponse<RawResponse>>;
+    usage: DeepReadonly<Usage>;
+};
+type AgentToolStartEvent = AgentLifecycleRunEvent & {
+    step: number;
+    toolName: string;
+    toolCallId?: string | undefined;
+    input: unknown;
+};
+type AgentToolFinishEventBase = AgentToolStartEvent & {
+    durationMs: number;
+};
+type AgentToolFinishEvent = (AgentToolFinishEventBase & {
+    success: true;
+    output: unknown;
+}) | (AgentToolFinishEventBase & {
+    success: false;
+    error: unknown;
+});
+type AgentFinishEvent = AgentLifecycleRunEvent & {
+    output: string;
+    usage: DeepReadonly<Usage>;
+    messages: DeepReadonly<Message[]>;
+};
+type AgentErrorEvent = AgentLifecycleRunEvent & {
+    error: unknown;
+    usage: DeepReadonly<Usage>;
+    messages: DeepReadonly<Message[]>;
+};
+type AgentLifecycle<RawResponse = unknown> = {
+    onStart?(event: AgentStartEvent): MaybePromise<void>;
+    onStepFinish?(event: AgentStepFinishEvent<RawResponse>): MaybePromise<void>;
+    onToolStart?(event: AgentToolStartEvent): MaybePromise<void>;
+    onToolFinish?(event: AgentToolFinishEvent): MaybePromise<void>;
+    onFinish?(event: AgentFinishEvent): MaybePromise<void>;
+    onError?(event: AgentErrorEvent): MaybePromise<void>;
+};
+
+type AgentInput = string | Message | Message[];
+type AgentRunOptions = {
+    maxTurns?: number | undefined;
+    retries?: RetryOptions | undefined;
+    lifecycle?: AgentLifecycle | undefined;
+    guardrails?: GuardrailPolicyInput | undefined;
+    toolConcurrency?: number | undefined;
+    middlewares?: readonly AgentMiddleware[] | undefined;
+    trace?: AgentTraceOptions | undefined;
+};
+type AgentResponse = {
+    status: "completed";
+    runId: string;
+    output: string;
+    usage: Usage;
+    contextUsage?: ContextUsage | undefined;
+    messages: Message[];
+    trace?: AgentTraceInfo | undefined;
+    guardrails?: GuardrailDecisionRecord[] | undefined;
+    sources?: CompletionSource[] | undefined;
+    providerToolCalls?: ProviderToolCall[] | undefined;
+};
+type AgentApprovalRequiredResult = {
+    status: "approval_required";
+    runId: string;
+    approval: AgentToolApprovalRequest;
+    usage: Usage;
+    messages: Message[];
+};
+type AgentResult = AgentResponse | AgentApprovalRequiredResult;
+type AgentToolApprovalRequest = {
+    id: string;
+    toolName: string;
+    toolCallId?: string | undefined;
+    reason?: string | undefined;
+    input: unknown;
+};
+type AgentApprovalRequiredEvent = Omit<AgentApprovalRequiredResult, "status"> & {
+    type: "approval_required";
+};
+type AgentApprovalDecision = {
+    approved: true;
+    reason?: string;
+} | {
+    approved: false;
+    reason?: string;
+};
+type AgentDeltaEvent = {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call";
+    toolCall: ToolCall;
+} | {
+    type: "source";
+    source: CompletionSource;
+} | {
+    type: "provider_tool_call";
+    toolCall: ProviderToolCall;
+};
+type AgentErrorStreamEvent = {
+    type: "error";
+    error: unknown;
+    usage: Usage;
+};
+type AgentStreamOptions = AgentRunOptions & {
+    /** @default true */
+    includeToolCallDeltas?: boolean;
+};
+type AgentToolCallDeltaEvent = {
+    type: "tool_call_delta";
+    turn: number;
+    id: string;
+    callId?: string;
+    name?: string;
+    argumentsDelta?: string;
+    argumentsMode?: ToolCallArgumentsMode;
+    signature?: string;
+};
+type AgentChildStreamEventBase<RawResponse = unknown> = {
+    type: "turn_start";
+    turn: number;
+    prompt: Message;
+    history: Message[];
+} | {
+    type: "generation_start";
+    turn: number;
+    request: CompletionRequest;
+    modelInfo: AgentGenerationModelInfo;
+} | {
+    type: "text_delta";
+    turn: number;
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    turn: number;
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call";
+    turn: number;
+    toolCall: ToolCall;
+} | {
+    type: "source";
+    turn: number;
+    source: CompletionSource;
+} | {
+    type: "provider_tool_call";
+    turn: number;
+    toolCall: ProviderToolCall;
+} | {
+    type: "tool_result";
+    turn: number;
+    toolName: string;
+    toolCallId?: string;
+    internalCallId: string;
+    args: string;
+    result: string;
+    structuredResult?: ToolResultContent[] | undefined;
+} | {
+    type: "turn_end";
+    turn: number;
+    response: CompletionResponse<RawResponse>;
+    firstDeltaMs?: number | undefined;
+} | {
+    type: "guardrail_decision";
+    turn?: number | undefined;
+    decision: GuardrailDecisionRecord;
+} | {
+    type: "final";
+    runId: string;
+    output: string;
+    usage: Usage;
+    contextUsage?: ContextUsage | undefined;
+    messages: Message[];
+    trace?: AgentTraceInfo | undefined;
+    guardrails?: GuardrailDecisionRecord[] | undefined;
+    sources?: CompletionSource[] | undefined;
+    providerToolCalls?: ProviderToolCall[] | undefined;
+} | AgentApprovalRequiredEvent | AgentErrorStreamEvent;
+type AgentChildStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse>;
+type AgentChildStreamEvent<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse> | AgentToolCallDeltaEvent;
+type AgentChildStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentChildStreamEvent<RawResponse>;
+type AgentToolStreamEvent<ChildEvent> = {
+    type: "agent_tool_event";
+    turn: number;
+    toolName: string;
+    toolCallId?: string;
+    internalCallId: string;
+    agentId: string;
+    agentName?: string;
+    event: ChildEvent;
+};
+type AgentStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventWithoutToolCallDeltas<RawResponse> | AgentToolStreamEvent<AgentChildStreamEventWithoutToolCallDeltas<RawResponse>>;
+type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse> | AgentToolStreamEvent<AgentChildStreamEvent<RawResponse>>;
+type AgentStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentStreamEvent<RawResponse>;
+interface AgentStream<Event = AgentStreamEvent> extends AsyncIterable<Event> {
+    steer(input: AgentInput): boolean;
+}
+
+type AgentTraceInfo = {
+    readonly traceId?: string | undefined;
+    readonly observationId?: string | undefined;
+};
+type AgentTraceOptions = {
+    readonly name?: string | undefined;
+    readonly userId?: string | undefined;
+    readonly sessionId?: string | undefined;
+    readonly metadata?: Readonly<Record<string, unknown>> | undefined;
+    readonly tags?: readonly string[] | undefined;
+    readonly version?: string | undefined;
+    readonly traceId?: string | undefined;
+    readonly failOnObserverError?: boolean | undefined;
+    readonly promptRef?: AgentRunPromptRef | undefined;
+};
+type AgentRunPromptRef = {
+    readonly name: string;
+    readonly version?: number | undefined;
+};
+type AgentRunStartArgs = {
+    readonly runId: string;
+    readonly agentName?: string | undefined;
+    readonly agentDescription?: string | undefined;
+    readonly instructions?: string | undefined;
+    readonly trace?: DeepReadonly<AgentTraceOptions> | undefined;
+    readonly prompt: DeepReadonly<Message>;
+    readonly promptRef?: DeepReadonly<AgentRunPromptRef> | undefined;
+    readonly history: readonly DeepReadonly<Message>[];
+    readonly maxTurns: number;
+};
+type AgentRunEndArgs = {
+    readonly output: string;
+    readonly usage: DeepReadonly<Usage>;
+    readonly messages: readonly DeepReadonly<Message>[];
+    readonly sources?: readonly DeepReadonly<CompletionSource>[] | undefined;
+    readonly providerToolCalls?: readonly DeepReadonly<ProviderToolCall>[] | undefined;
+};
+type AgentRunErrorArgs = {
+    readonly error: unknown;
+    readonly usage: DeepReadonly<Usage>;
+    readonly messages: readonly DeepReadonly<Message>[];
+};
+type AgentGenerationModelInfo = {
+    readonly provider: string;
+    readonly defaultModel: string;
+    readonly capabilities?: DeepReadonly<CompletionModelCapabilities> | undefined;
+};
+type AgentGenerationStartArgs = {
+    readonly turn: number;
+    readonly request: DeepReadonly<CompletionRequest>;
+    readonly providerRequest?: DeepReadonly<JsonObject> | undefined;
+    readonly modelInfo?: DeepReadonly<AgentGenerationModelInfo> | undefined;
+};
+type AgentGenerationEndArgs<RawResponse = unknown> = {
+    readonly turn: number;
+    readonly response: DeepReadonly<CompletionResponse<RawResponse>>;
+    readonly firstDeltaMs?: number | undefined;
+};
+type AgentGenerationErrorArgs = {
+    readonly turn: number;
+    readonly error: unknown;
+};
+type AgentGenerationUpdateArgs = {
+    readonly turn: number;
+    readonly delta: DeepReadonly<AgentDeltaEvent>;
+};
+type AgentRunEventArgs = {
+    readonly name: string;
+    readonly attributes?: Readonly<Record<string, DeepReadonly<JsonValue> | undefined>> | undefined;
+    readonly level?: "DEFAULT" | "WARNING" | "ERROR" | undefined;
+    readonly timestamp?: Date | string | undefined;
+};
+type AgentToolStartArgs = {
+    readonly turn: number;
+    readonly toolCall: DeepReadonly<ToolCall>;
+    readonly toolName: string;
+    readonly args: string;
+    readonly internalCallId: string;
+    readonly toolCallId?: string | undefined;
+    readonly toolDefinition?: DeepReadonly<ToolDefinition> | undefined;
+    readonly toolMetadata?: DeepReadonly<JsonObject> | undefined;
+};
+type AgentToolEndArgs = AgentToolStartArgs & {
+    readonly result: string;
+    readonly structuredResult?: readonly DeepReadonly<ToolResultContent>[] | undefined;
+    readonly skipped: boolean;
+};
+type AgentToolErrorArgs = AgentToolStartArgs & {
+    readonly error: unknown;
+};
+type AgentToolStreamEventArgs = AgentToolStartArgs & {
+    readonly event: DeepReadonly<ToolCallStreamEvent>;
+};
+interface AgentGenerationObserver {
+    end(args: AgentGenerationEndArgs): void | Promise<void>;
+    error?(args: AgentGenerationErrorArgs): void | Promise<void>;
+    update?(args: AgentGenerationUpdateArgs): void | Promise<void>;
+}
+interface AgentToolObserver {
+    streamEvent?(args: AgentToolStreamEventArgs): void | Promise<void>;
+    end(args: AgentToolEndArgs): void | Promise<void>;
+    error?(args: AgentToolErrorArgs): void | Promise<void>;
+}
+interface AgentRunObserver {
+    readonly trace?: AgentTraceInfo | undefined;
+    startGeneration?(args: AgentGenerationStartArgs): AgentGenerationObserver | undefined | Promise<AgentGenerationObserver | undefined>;
+    startTool?(args: AgentToolStartArgs): AgentToolObserver | undefined | Promise<AgentToolObserver | undefined>;
+    end(args: AgentRunEndArgs): void | Promise<void>;
+    error?(args: AgentRunErrorArgs): void | Promise<void>;
+    event?(args: AgentRunEventArgs): void | Promise<void>;
+}
+interface AgentObserver {
+    startRun(args: AgentRunStartArgs): AgentRunObserver | undefined | Promise<AgentRunObserver | undefined>;
+    flush?(): void | Promise<void>;
+    shutdown?(): void | Promise<void>;
+}
+type AgentObserverRegistration = {
+    readonly observer: AgentObserver;
+    readonly failOnObserverError?: boolean | undefined;
+};
+type ObserveOptions = {
+    readonly failOnObserverError?: boolean | undefined;
+};
+declare function createObserver(observer: AgentObserver): AgentObserver;
+
+export { type AgentApprovalDecision as A, type AgentObserverRegistration as B, type AgentGenerationEndArgs as C, type AgentGenerationErrorArgs as D, type AgentGenerationModelInfo as E, type AgentGenerationObserver as F, type AgentGenerationStartArgs as G, type AgentGenerationUpdateArgs as H, type AgentRunEndArgs as I, type AgentRunErrorArgs as J, type AgentRunEventArgs as K, type AgentRunObserver as L, type AgentRunPromptRef as M, type AgentRunStartArgs as N, type ObserveOptions as O, type AgentToolEndArgs as P, type AgentToolErrorArgs as Q, type AgentToolObserver as R, type AgentToolStartArgs as S, type AgentToolStreamEventArgs as T, type AgentTraceInfo as U, type AgentTraceOptions as V, createObserver as W, type AgentApprovalRequiredEvent as a, type AgentApprovalRequiredResult as b, type AgentChildStreamEvent as c, type AgentChildStreamEventWithToolCallDeltas as d, type AgentChildStreamEventWithoutToolCallDeltas as e, type AgentDeltaEvent as f, type AgentErrorEvent as g, type AgentErrorStreamEvent as h, type AgentFinishEvent as i, type AgentInput as j, type AgentLifecycle as k, type AgentResponse as l, type AgentResult as m, type AgentRunOptions as n, type AgentStartEvent as o, type AgentStepFinishEvent as p, type AgentStream as q, type AgentStreamEvent as r, type AgentStreamEventWithToolCallDeltas as s, type AgentStreamEventWithoutToolCallDeltas as t, type AgentStreamOptions as u, type AgentToolApprovalRequest as v, type AgentToolCallDeltaEvent as w, type AgentToolFinishEvent as x, type AgentToolStartEvent as y, type AgentObserver as z };

package/dist/index.d.ts

@@ -1,25 +1,28 @@
-export { AgentBuilder } from './agent/index.js';
-export { C as CreateCompletionBaseOptions, a as CreateCompletionInput, b as CreateCompletionOptions, c as CreateCompletionResult, d as CreateCompletionStreamOptions, e as CreateParsedCompletionOptions, f as CreateParsedCompletionResult, g as createCompletion, h as createCompletionStream, i as createParsedCompletion, j as isJsonValue } from './json-BVPssigK.js';
-export { A as AssistantContent, a as AssistantGenerationMetadata, b as AssistantMessage, c as AssistantMessageOptions, C as CompletionModel, d as CompletionModelInfo, e as CompletionModelMetadataOptions, f as CompletionRequest, g as CompletionResponse, h as CompletionSource, i as CompletionTool, j as ContextUsage, D as Document, I as ImageContent, J as JsonObject, k as JsonPrimitive, l as JsonValue, M as Message, m as MessageOptions, n as ModelContextLimits, P as ProviderTool, o as ProviderToolCall, S as SystemMessage, T as Text, p as ToolCall, q as ToolContent, r as ToolDefinition, s as ToolMessage, t as ToolResult, u as ToolResultContent, v as ToolResultMessageOptions, w as ToolResultOptions, U as Usage, x as UserContent, y as UserMessage, z as calculateContextUsage, B as getAssistantGenerationMetadata, E as isProviderTool, F as resolveCompletionModelInfo, G as withContextUsage } from './types-G12i56s2.js';
+export { A as Agent, a as AgentContextInput, b as AgentMemoryOptions, c as AgentObserverInput, d as AgentOptions, e as AgentSession, f as AgentToolInput, g as AgentToolOptions, C as ContextIndex, h as CreateContextIndexOptions, i as createContextIndex, j as isContextIndex } from './agent-DGYY_onS.js';
+export { AgentRunCancelledError, MaxTurnsError } from './agent/index.js';
+export { A as AgentApprovalDecision, a as AgentApprovalRequiredEvent, b as AgentApprovalRequiredResult, c as AgentChildStreamEvent, d as AgentChildStreamEventWithToolCallDeltas, e as AgentChildStreamEventWithoutToolCallDeltas, f as AgentDeltaEvent, g as AgentErrorEvent, h as AgentErrorStreamEvent, i as AgentFinishEvent, j as AgentInput, k as AgentLifecycle, l as AgentResponse, m as AgentResult, n as AgentRunOptions, o as AgentStartEvent, p as AgentStepFinishEvent, q as AgentStream, r as AgentStreamEvent, s as AgentStreamEventWithToolCallDeltas, t as AgentStreamEventWithoutToolCallDeltas, u as AgentStreamOptions, v as AgentToolApprovalRequest, w as AgentToolCallDeltaEvent, x as AgentToolFinishEvent, y as AgentToolStartEvent } from './index-DxB74ybJ.js';
+export { R as RetryContext, a as RetryOptions } from './retry-D3Ruy-ba.js';
+export { AudioGenerationModel, AudioGenerationRequest, AudioGenerationResponse, GenerateSpeechOptions, generateSpeech } from './audio-generation/index.js';
+export { C as CreateCompletionBaseOptions, a as CreateCompletionInput, b as CreateCompletionOptions, c as CreateCompletionResult, d as CreateCompletionStreamOptions, e as CreateParsedCompletionOptions, f as CreateParsedCompletionResult, g as createCompletion, h as createCompletionStream, i as createParsedCompletion, j as isJsonValue } from './json-Zo7K3xmt.js';
+export { A as AssistantContent, a as AssistantGenerationMetadata, b as AssistantMessage, c as AssistantMessageOptions, C as CompletionModel, d as CompletionModelInfo, e as CompletionModelMetadataOptions, f as CompletionRequest, g as CompletionResponse, h as CompletionSource, i as CompletionTool, j as ContextUsage, D as Document, I as ImageContent, J as JsonObject, k as JsonPrimitive, l as JsonValue, M as Message, m as MessageOptions, n as ModelContextLimits, P as ProviderTool, o as ProviderToolCall, S as SystemMessage, T as Text, p as ToolCall, q as ToolContent, r as ToolDefinition, s as ToolMessage, t as ToolResult, u as ToolResultContent, v as ToolResultMessageOptions, w as ToolResultOptions, U as Usage, x as UserContent, y as UserMessage, z as calculateContextUsage, B as getAssistantGenerationMetadata, E as isProviderTool, F as resolveCompletionModelInfo, G as withContextUsage } from './types-B3A4YxaA.js';
 export { GuardrailBoundary, GuardrailDecisionRecord, GuardrailMode, GuardrailPolicy, GuardrailPolicyInput, GuardrailPolicyOptions, InputGuardrail, InputGuardrailActions, InputGuardrailContext, OutputGuardrail, OutputGuardrailActions, OutputGuardrailContext, allow, block, defineGuardrailPolicy, defineInputGuardrail, defineOutputGuardrail, guardrails } from './guardrails/index.js';
-export { cancelPrompt, createHook, requestToolApproval, runControl, skipTool, toolCallControl } from './hooks/index.js';
-export { M as MemoryCompactionConflictError, a as MemoryCompactionError, c as createSummaryMemoryCompactor, i as isMemoryCompactionSummary } from './errors-2moLDuuN.js';
-export { M as MemoryCompactionCommitInput, a as MemoryCompactionCommitResult, b as MemoryCompactionOptions, c as MemoryCompactionSnapshot, d as MemoryCompactionStore, e as MemoryCompactor, f as MemoryCompactorInput, g as MemoryCompactorResult, h as MemoryConversation, i as MemoryConversationListOptions, j as MemoryConversationMessage, k as MemoryConversationSummary, l as MemoryInspector, m as MemoryStore, R as ResolvedMemoryCompactionOptions, S as SummaryMemoryCompactorOptions } from './types-BrLbKnEz.js';
-export { MaxTurnsError, PromptCancelledError, ToolApprovalRequiredError } from './request/index.js';
-export { C as CompletionRetryContext, a as CompletionRetryOptions } from './agent-x3YTyv5i.js';
-export { A as AgentChildStreamEvent, a as AgentChildStreamEventWithToolCallDeltas, b as AgentChildStreamEventWithoutToolCallDeltas, c as AgentErrorStreamEvent, d as AgentStreamEvent, e as AgentStreamEventWithToolCallDeltas, f as AgentStreamEventWithoutToolCallDeltas, g as AgentStreamOptions, h as AgentToolCallDeltaEvent, P as PromptResponse } from './index-BxSbmOMr.js';
+export { GenerateImageOptions, GeneratedImage, ImageGenerationModel, ImageGenerationRequest, ImageGenerationResponse, generateImage } from './image-generation/index.js';
+export { M as MemoryCompactionConflictError, a as MemoryCompactionError, c as createSummaryMemoryCompactor, i as isMemoryCompactionSummary } from './errors-CYKUcU89.js';
+export { M as MemoryCompactionCommitInput, a as MemoryCompactionCommitResult, b as MemoryCompactionOptions, c as MemoryCompactionSnapshot, d as MemoryCompactionStore, e as MemoryCompactor, f as MemoryCompactorInput, g as MemoryCompactorResult, h as MemoryConversation, i as MemoryConversationListOptions, j as MemoryConversationMessage, k as MemoryConversationSummary, l as MemoryInspector, m as MemoryStore, R as ResolvedMemoryCompactionOptions, S as SummaryMemoryCompactorOptions } from './types-BBEGKB9m.js';
 export { Z as ZodSchema } from './zod-schema-C7F4clpm.js';
 export { loadSkills, skill } from './skills/index.js';
-export { S as SkillValidationError } from './types-04LqWrmy.js';
-export { C as CreateToolOptions, c as createThinkTool, a as createTool } from './think-tool-DfCMuO8e.js';
-export { A as AnyTool, T as Tool, a as ToolApprovalContext, b as ToolApprovalDecision, c as ToolApprovalPolicy, d as ToolApprovalRequest, e as ToolApprovalsOptions, f as ToolCallContext, g as ToolCallStreamEvent } from './tool-Cohdv5GC.js';
-export { A as AgentMiddleware, C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, e as ToolOutputMiddlewareArgs, f as ToolOutputMiddlewareResult, g as ToolResultMiddlewareArgs, h as createMiddleware } from './middleware-Dp3d_pxi.js';
+export { S as SkillValidationError } from './types-DhQfwiZn.js';
+export { C as CreateToolOptions, c as createThinkTool, a as createTool } from './think-tool-DZqZj2LV.js';
+export { A as AnyTool, T as Tool, a as ToolApprovalContext, b as ToolApprovalRequirement, c as ToolCallContext, d as ToolCallStreamEvent, e as ToolRequiresApproval } from './tool-C_8GudXn.js';
+export { A as AgentMiddleware, C as CompletionRequestMiddlewareArgs, a as CompletionRequestMiddlewareResult, b as CompletionResponseMiddlewareArgs, c as CompletionResponseMiddlewareResult, T as ToolInputMiddlewareArgs, d as ToolInputMiddlewareResult, e as ToolOutputMiddlewareArgs, f as ToolOutputMiddlewareResult, g as ToolResultMiddlewareArgs, h as createMiddleware } from './middleware-KynLg_RW.js';
+export { TranscribeOptions, TranscriptionModel, TranscriptionRequest, TranscriptionResponse, transcribe } from './transcription/index.js';
 export { CreateUIAttachment, UIAttachment, UIError, UIMessage, UIMessagePart, UIMessageRole, UIStreamEvent, UIStreamRequest, UIStreamResume, coreMessagesToUIMessages, uiMessagesToCoreMessages } from './ui/index.js';
-import './types-D9JpeAPF.js';
-import './types-JJCxRnaZ.js';
+import './types-DulRCYdB.js';
 import '@modelcontextprotocol/sdk/client/sse.js';
 import '@modelcontextprotocol/sdk/client/stdio.js';
 import '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import './types-O-abTIin.js';
-import './types-BCTRUGex.js';
+import './dynamic-tools-i9woysFa.js';
+import './types-p55Jc-sr.js';
+import './types-DT3nEemY.js';
+import './type-utils-CtHVDRn_.js';
 import 'zod';