import { i as AssistantMessageEvent$1, r as AssistantMessage$1 } from "./types-CBQ0-JNc.js";
import { TSchema } from "typebox";

//#region packages/agent-core/src/llm.d.ts
type Api = string;
type CacheRetention = "none" | "short" | "long";
type Transport = "sse" | "websocket" | "websocket-cached" | "auto";
type ThinkingLevel = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
type ModelThinkingLevel = "off" | ThinkingLevel;
type MaybePromise<T> = T | Promise<T>;
interface ProviderResponse {
  status: number;
  headers: Record<string, string>;
}
interface ThinkingBudgets {
  minimal?: number;
  low?: number;
  medium?: number;
  high?: number;
  max?: number;
}
interface DiagnosticErrorInfo {
  name?: string;
  message: string;
  stack?: string;
  code?: string | number;
}
interface AssistantMessageDiagnostic {
  type: string;
  timestamp: number;
  error?: DiagnosticErrorInfo;
  details?: Record<string, unknown>;
}
interface SimpleStreamOptions {
  temperature?: number;
  maxTokens?: number;
  signal?: AbortSignal;
  apiKey?: string;
  transport?: Transport;
  cacheRetention?: CacheRetention;
  sessionId?: string;
  onPayload?: (payload: unknown, model: Model) => MaybePromise<unknown>;
  onResponse?: (response: ProviderResponse, model: Model) => void | Promise<void>;
  headers?: Record<string, string>;
  timeoutMs?: number;
  maxRetries?: number;
  maxRetryDelayMs?: number;
  metadata?: Record<string, unknown>;
  reasoning?: ThinkingLevel;
  thinkingBudgets?: ThinkingBudgets;
}
interface TextContent {
  type: "text";
  text: string;
  textSignature?: string;
}
interface ThinkingContent {
  type: "thinking";
  thinking: string;
  thinkingSignature?: string;
  redacted?: boolean;
}
interface ImageContent {
  type: "image";
  data: string;
  mimeType: string;
}
interface ToolCall {
  type: "toolCall";
  id: string;
  name: string;
  arguments: Record<string, unknown>;
  thoughtSignature?: string;
  executionMode?: "sequential" | "parallel";
}
interface Usage {
  input: number;
  output: number;
  cacheRead: number;
  cacheWrite: number;
  totalTokens: number;
  cost: {
    input: number;
    output: number;
    cacheRead: number;
    cacheWrite: number;
    total: number;
  };
}
type StopReason = "stop" | "length" | "toolUse" | "aborted" | "error";
interface UserMessage {
  role: "user";
  content: string | (TextContent | ImageContent)[];
  timestamp: number;
}
interface AssistantMessage {
  role: "assistant";
  content: (TextContent | ThinkingContent | ToolCall)[];
  api: Api;
  provider: string;
  model: string;
  responseModel?: string;
  responseId?: string;
  diagnostics?: AssistantMessageDiagnostic[];
  stopReason: StopReason;
  errorMessage?: string;
  timestamp: number;
  usage: Usage;
}
interface ToolResultMessage {
  role: "toolResult";
  toolCallId: string;
  toolName: string;
  content: (TextContent | ImageContent)[];
  isError: boolean;
  details?: unknown;
  timestamp: number;
}
type Message = UserMessage | AssistantMessage | ToolResultMessage;
interface Context {
  systemPrompt?: string;
  messages: Message[];
  tools?: Tool[];
}
interface Model<TApi extends Api = Api> {
  id: string;
  name: string;
  api: TApi;
  provider: string;
  baseUrl: string;
  input: ("text" | "image")[];
  reasoning: boolean;
  thinkingLevelMap?: Partial<Record<ModelThinkingLevel, string | null>>;
  contextWindow: number;
  maxTokens: number;
  cost: {
    input: number;
    output: number;
    cacheRead: number;
    cacheWrite: number;
  };
  headers?: Record<string, string>;
  compat?: any;
}
interface Tool<TParameters extends TSchema = TSchema> {
  name: string;
  description: string;
  parameters: TParameters;
}
type AssistantMessageEvent = {
  type: "start";
  partial: AssistantMessage;
} | {
  type: "text_start";
  contentIndex: number;
  partial: AssistantMessage;
} | {
  type: "text_delta";
  contentIndex: number;
  delta: string;
  partial: AssistantMessage;
} | {
  type: "text_end";
  contentIndex: number;
  content: string;
  partial: AssistantMessage;
} | {
  type: "thinking_start";
  contentIndex: number;
  partial: AssistantMessage;
} | {
  type: "thinking_delta";
  contentIndex: number;
  delta: string;
  partial: AssistantMessage;
} | {
  type: "thinking_end";
  contentIndex: number;
  content: string;
  partial: AssistantMessage;
} | {
  type: "toolcall_start";
  contentIndex: number;
  partial: AssistantMessage;
} | {
  type: "toolcall_delta";
  contentIndex: number;
  delta: string;
  partial: AssistantMessage;
} | {
  type: "toolcall_end";
  contentIndex: number;
  toolCall: ToolCall;
  partial: AssistantMessage;
} | {
  type: "done";
  reason: Extract<StopReason, "stop" | "length" | "toolUse">;
  message: AssistantMessage;
} | {
  type: "error";
  reason: Extract<StopReason, "aborted" | "error">;
  error: AssistantMessage;
};
declare class EventStream$1<T, R = T> implements AsyncIterable<T> {
  private readonly isComplete;
  private readonly extractResult;
  private queue;
  private waiting;
  private done;
  private finalResultPromise;
  private resolveFinalResult;
  constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
  push(event: T): void;
  end(result?: R): void;
  [Symbol.asyncIterator](): AsyncIterator<T>;
  result(): Promise<R>;
}
interface AssistantMessageEventStream$1 extends AsyncIterable<AssistantMessageEvent> {
  result(): Promise<AssistantMessage>;
}
type StreamFn = (model: Model, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream$1 | Promise<AssistantMessageEventStream$1>;
type CompleteSimpleFn = (model: Model, context: Pick<Context, "systemPrompt" | "messages">, options?: SimpleStreamOptions) => Promise<AssistantMessage>;
//#endregion
//#region packages/agent-core/src/validation.d.ts
declare function validateToolCall(tools: Tool[], toolCall: ToolCall): unknown;
declare function validateToolArguments(tool: Tool, toolCall: ToolCall): unknown;
//#endregion
//#region src/llm/utils/event-stream.d.ts
declare class EventStream<T, R = T> implements AsyncIterable<T> {
  private queue;
  private waiting;
  private done;
  private finalResultPromise;
  private resolveFinalResult;
  private isComplete;
  private extractResult;
  constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
  push(event: T): void;
  end(result?: R): void;
  [Symbol.asyncIterator](): AsyncIterator<T>;
  result(): Promise<R>;
}
declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent$1, AssistantMessage$1> {
  constructor();
}
/** Factory function for AssistantMessageEventStream (for use in extensions) */
declare function createAssistantMessageEventStream(): AssistantMessageEventStream;
//#endregion
export { Tool as _, validateToolCall as a, Usage as b, CompleteSimpleFn as c, Message as d, Model as f, ThinkingBudgets as g, TextContent as h, validateToolArguments as i, EventStream$1 as l, StreamFn as m, EventStream as n, AssistantMessage as o, SimpleStreamOptions as p, createAssistantMessageEventStream as r, AssistantMessageEvent as s, AssistantMessageEventStream as t, ImageContent as u, ToolResultMessage as v, Transport as y };