import { $i as NodeExecutionContext, $t as ConnectionInvocationId, Ao as CredentialRequirement, Et as Expr, Go as NodeConnectionName, Ko as NodeId, Or as NodeConfigBase, Rr as NodeOutputs, Tr as JsonValue, Un as TypeToken, Xr as RunnableNodeInputJson, Y as McpServerDeclaration, Ya as TelemetrySpanScope, Yr as RunnableNodeConfig, br as Items, vr as Item } from "./index-CRv3_pY3.js";
import { ZodType, input, output } from "zod";

//#region src/ai/NodeBackedToolConfig.d.ts

declare class NodeBackedToolConfig<TNodeConfig extends RunnableNodeConfig<any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> implements ToolConfig {
  readonly name: string;
  readonly node: TNodeConfig;
  readonly type: TypeToken<unknown>;
  readonly toolKind: "nodeBacked";
  readonly description?: string;
  readonly presentation?: AgentCanvasPresentation;
  readonly onRejected?: "halt" | "return";
  private readonly inputSchemaValue;
  private readonly outputSchemaValue;
  private readonly mapInputValue?;
  private readonly mapOutputValue?;
  constructor(name: string, node: TNodeConfig, options: NodeBackedToolConfigOptions<TNodeConfig, TInputSchema, TOutputSchema>);
  getCredentialRequirements(): ReadonlyArray<CredentialRequirement>;
  getInputSchema(): TInputSchema;
  getOutputSchema(): TOutputSchema;
  toNodeItem(args: NodeBackedToolInputMapperArgs<TNodeConfig, input<TInputSchema>>): Item<RunnableNodeInputJson<TNodeConfig>>;
  toToolOutput(args: NodeBackedToolOutputMapperArgs<TNodeConfig, input<TInputSchema>>): output<TOutputSchema>;
  private readDefaultToolOutput;
  private isItem;
}
//#endregion
//#region src/ai/CallableToolConfig.d.ts
type CallableToolExecuteHandler<TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> = (args: ToolExecuteArgs<CallableToolConfig<TInputSchema, TOutputSchema>, input<TInputSchema>>) => Promise<output<TOutputSchema>> | output<TOutputSchema>;
type CallableToolConfigOptions<TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> = Readonly<{
  name: string;
  description?: string;
  presentation?: AgentCanvasPresentation;
  inputSchema: TInputSchema;
  outputSchema: TOutputSchema;
  credentialRequirements?: ReadonlyArray<CredentialRequirement>;
  execute: CallableToolExecuteHandler<TInputSchema, TOutputSchema>;
}>;
declare class CallableToolConfig<TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> implements ToolConfig {
  readonly name: string;
  readonly type: TypeToken<unknown>;
  readonly toolKind: "callable";
  readonly description?: string;
  readonly presentation?: AgentCanvasPresentation;
  private readonly inputSchemaValue;
  private readonly outputSchemaValue;
  private readonly credentialRequirementsValue?;
  private readonly executeHandler;
  constructor(name: string, options: CallableToolConfigOptions<TInputSchema, TOutputSchema>);
  getCredentialRequirements(): ReadonlyArray<CredentialRequirement>;
  getInputSchema(): TInputSchema;
  getOutputSchema(): TOutputSchema;
  executeTool(args: ToolExecuteArgs<CallableToolConfig<TInputSchema, TOutputSchema>, input<TInputSchema>>): Promise<output<TOutputSchema>>;
  private parseInput;
  private parseOutput;
  private decorateValidationError;
}
//#endregion
//#region src/ai/CallableToolFactory.d.ts
declare class CallableToolFactoryImpl {
  callableTool<TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny>(options: CallableToolConfigOptions<TInputSchema, TOutputSchema>): CallableToolConfig<TInputSchema, TOutputSchema>;
}
declare const CallableToolFactory: CallableToolFactoryImpl;
//#endregion
//#region src/ai/CallableToolKindToken.d.ts
declare class CallableToolKindToken {}
//#endregion
//#region src/ai/AgentToolFactory.d.ts
declare class AgentToolFactoryImpl {
  asTool<TNodeConfig extends RunnableNodeConfig<any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny>(node: TNodeConfig, options: Readonly<{
    name?: string;
  } & NodeBackedToolConfigOptions<TNodeConfig, TInputSchema, TOutputSchema>>): NodeBackedToolConfig<TNodeConfig, TInputSchema, TOutputSchema>;
  private withDefaultAgentInputMapper;
  private mergeAgentToolInputWithCurrentItem;
  private isMergeableRecord;
}
declare const AgentToolFactory: AgentToolFactoryImpl;
//#endregion
//#region src/ai/AgentMessageConfigNormalizerFactory.d.ts
declare class AgentMessageConfigNormalizer {
  static resolveFromInputOrConfig<TInputJson, TOutputJson>(input: unknown, config: AgentNodeConfig<TInputJson, TOutputJson>, args: AgentMessageBuildArgs<TInputJson>): ReadonlyArray<AgentMessageDto>;
  static normalize<TInputJson, TOutputJson>(config: AgentNodeConfig<TInputJson, TOutputJson>, args: AgentMessageBuildArgs<TInputJson>): ReadonlyArray<AgentMessageDto>;
  private static tryMessagesFromStructuredInput;
  private static normalizeRichMessages;
  private static lineToDto;
}
//#endregion
//#region src/ai/AgentConfigInspectorFactory.d.ts
declare class AgentConfigInspector {
  static isAgentNodeConfig(config: NodeConfigBase | undefined): config is AgentNodeConfig<any, any>;
  private static hasCompatibleMessageConfiguration;
}
//#endregion
//#region src/ai/AiHost.d.ts
interface AgentCanvasPresentation<TIcon extends string = string> {
  readonly label?: string;
  readonly icon?: TIcon;
}
type ZodSchemaAny = ZodType<any, any, any>;
interface ToolConfig {
  readonly type: TypeToken<unknown>;
  readonly name: string;
  readonly description?: string;
  readonly presentation?: AgentCanvasPresentation;
  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
}
type ToolExecuteArgs<TConfig extends ToolConfig = ToolConfig, TInput = unknown> = Readonly<{
  config: TConfig;
  input: TInput;
  ctx: NodeExecutionContext<any>;
  item: Item;
  itemIndex: number;
  items: Items;
  hooks?: Readonly<{
    parentSpan?: TelemetrySpanScope;
    parentInvocationId?: ConnectionInvocationId;
  }>;
}>;
interface Tool<TConfig extends ToolConfig = ToolConfig, TInputSchema extends ZodSchemaAny = ZodSchemaAny, TOutputSchema extends ZodSchemaAny = ZodSchemaAny> {
  readonly defaultDescription: string;
  readonly inputSchema: TInputSchema;
  readonly outputSchema: TOutputSchema;
  execute(args: ToolExecuteArgs<TConfig, input<TInputSchema>>): Promise<output<TOutputSchema>> | output<TOutputSchema>;
}
type AgentTool<TInputSchema extends ZodSchemaAny = ZodSchemaAny, TOutputSchema extends ZodSchemaAny = ZodSchemaAny> = Tool<ToolConfig, TInputSchema, TOutputSchema>;
type AgentToolExecuteArgs<TInput = unknown> = ToolExecuteArgs<ToolConfig, TInput>;
type AgentToolToken = TypeToken<Tool<ToolConfig, ZodSchemaAny, ZodSchemaAny>>;
type AgentMessageRole = "system" | "user" | "assistant";
type AgentMessageBuildArgs<TInputJson = unknown> = Readonly<{
  item: Item<TInputJson>;
  itemIndex: number;
  items: Items<TInputJson>;
  ctx: NodeExecutionContext<any>;
}>;
interface AgentMessageDto {
  readonly role: AgentMessageRole;
  readonly content: string;
}
type AgentMessageTemplateContent<TInputJson = unknown> = string | ((args: AgentMessageBuildArgs<TInputJson>) => string);
interface AgentMessageTemplate<TInputJson = unknown> {
  readonly role: AgentMessageRole;
  readonly content: AgentMessageTemplateContent<TInputJson>;
}
type AgentMessageLine<TInputJson = unknown> = AgentMessageDto | AgentMessageTemplate<TInputJson>;
type AgentMessageConfig<TInputJson = unknown> = Expr<ReadonlyArray<AgentMessageLine<TInputJson>>, TInputJson> | ReadonlyArray<AgentMessageLine<TInputJson>> | {
  readonly prompt?: ReadonlyArray<AgentMessageLine<TInputJson>>;
  readonly buildMessages?: (args: AgentMessageBuildArgs<TInputJson>) => ReadonlyArray<AgentMessageDto>;
};
type AgentTurnLimitBehavior = "error" | "respondWithLastMessage";
interface AgentModelInvocationOptions {
  readonly maxTokens?: number;
  readonly providerOptions?: Readonly<Record<string, JsonValue>>;
}
interface AgentGuardrailConfig {
  readonly maxTurns?: number;
  readonly onTurnLimitReached?: AgentTurnLimitBehavior;
  readonly modelInvocationOptions?: AgentModelInvocationOptions;
}
declare const AgentGuardrailDefaults: {
  readonly maxTurns: 10;
  readonly onTurnLimitReached: AgentTurnLimitBehavior;
};
interface AgentToolDefinition {
  readonly name: string;
  readonly description: string;
  readonly inputSchema: ZodSchemaAny;
}
type AgentToolCall = Readonly<{
  id?: string;
  name: string;
  input: unknown;
}>;
type AgentToolCallPlanner<_TNodeConfig = unknown> = (item: Item, index: number, items: Items, ctx: NodeExecutionContext<any>) => ReadonlyArray<AgentToolCall>;
interface ChatModelConfig {
  readonly type: TypeToken<ChatModelFactory<ChatModelConfig>>;
  readonly name: string;
  readonly provider?: string;
  readonly modelName?: string;
  readonly presentation?: AgentCanvasPresentation;
  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
}
interface ChatLanguageModel {
  readonly languageModel: unknown;
  readonly modelName: string;
  readonly provider?: string;
  readonly defaultCallOptions?: ChatLanguageModelCallOptions;
}
interface ChatLanguageModelCallOptions {
  readonly maxOutputTokens?: number;
  readonly temperature?: number;
  readonly providerOptions?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
}
interface StructuredOutputOptions {
  readonly schemaName?: string;
  readonly strict?: boolean;
}
interface ChatModelFactory<TConfig extends ChatModelConfig = ChatModelConfig> {
  create(args: Readonly<{
    config: TConfig;
    ctx: NodeExecutionContext<any>;
  }>): Promise<ChatLanguageModel> | ChatLanguageModel;
}
type NodeBackedToolInputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = Readonly<{
  input: TToolInput;
  item: Item;
  itemIndex: number;
  items: Items;
  ctx: NodeExecutionContext<any>;
  node: TNodeConfig;
}>;
type NodeBackedToolOutputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = Readonly<{
  input: TToolInput;
  item: Item;
  itemIndex: number;
  items: Items;
  ctx: NodeExecutionContext<any>;
  node: TNodeConfig;
  outputs: NodeOutputs;
}>;
type NodeBackedToolInputMapper<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = (args: NodeBackedToolInputMapperArgs<TNodeConfig, TToolInput>) => Item<RunnableNodeInputJson<TNodeConfig>> | RunnableNodeInputJson<TNodeConfig>;
type NodeBackedToolOutputMapper<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown, TToolOutput = unknown> = (args: NodeBackedToolOutputMapperArgs<TNodeConfig, TToolInput>) => TToolOutput;
type NodeBackedToolConfigOptions<TNodeConfig extends RunnableNodeConfig<any, any>, TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny> = Readonly<{
  description?: string;
  presentation?: AgentCanvasPresentation;
  inputSchema: TInputSchema;
  outputSchema: TOutputSchema;
  mapInput?: NodeBackedToolInputMapper<TNodeConfig, input<TInputSchema>>;
  mapOutput?: NodeBackedToolOutputMapper<TNodeConfig, input<TInputSchema>, output<TOutputSchema>>;
  onRejected?: "halt" | "return";
}>;
interface AgentNodeConfig<TInputJson = unknown, TOutputJson = unknown> extends RunnableNodeConfig<TInputJson, TOutputJson> {
  readonly messages: AgentMessageConfig<TInputJson>;
  readonly chatModel: ChatModelConfig;
  readonly tools?: ReadonlyArray<ToolConfig>;
  readonly guardrails?: AgentGuardrailConfig;
  readonly outputSchema?: ZodType<TOutputJson>;
}
type AgentAttachmentRole = "languageModel" | "tool" | "nestedAgent";
//#endregion
//#region src/ai/AgentConnectionNodeCollector.d.ts
type AgentConnectionNodeRole = "languageModel" | "tool" | "nestedAgent";
type AgentConnectionCredentialSource = Readonly<{
  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
}>;
type AgentConnectionNodeDescriptor = Readonly<{
  nodeId: NodeId;
  parentNodeId: NodeId;
  connectionName: NodeConnectionName;
  role: AgentConnectionNodeRole;
  name: string;
  typeName: string;
  icon?: string;
  credentialSource: AgentConnectionCredentialSource;
}>;
type McpServerResolver = (id: string) => McpServerDeclaration | undefined;
type AgentConnectionNodeCollectorApi = Readonly<{
  collect(parentNodeId: NodeId, agentConfig: AgentNodeConfig<any, any>, mcpServerResolver?: McpServerResolver): ReadonlyArray<AgentConnectionNodeDescriptor>;
}>;
declare const AgentConnectionNodeCollector: AgentConnectionNodeCollectorApi;
//#endregion
//#region src/serialization/ItemsInputNormalizer.d.ts
declare class ItemsInputNormalizer {
  normalize(raw: unknown): Items;
  private normalizeItem;
  private isItem;
}
//#endregion
export { ChatModelFactory as A, ZodSchemaAny as B, AgentToolDefinition as C, ChatLanguageModel as D, AgentTurnLimitBehavior as E, NodeBackedToolOutputMapperArgs as F, CallableToolFactory as G, AgentMessageConfigNormalizer as H, StructuredOutputOptions as I, CallableToolExecuteHandler as J, CallableToolConfig as K, Tool as L, NodeBackedToolInputMapper as M, NodeBackedToolInputMapperArgs as N, ChatLanguageModelCallOptions as O, NodeBackedToolOutputMapper as P, ToolConfig as R, AgentToolCallPlanner as S, AgentToolToken as T, AgentToolFactory as U, AgentConfigInspector as V, CallableToolKindToken as W, NodeBackedToolConfig as Y, AgentMessageTemplateContent as _, AgentConnectionNodeRole as a, AgentTool as b, AgentCanvasPresentation as c, AgentMessageBuildArgs as d, AgentMessageConfig as f, AgentMessageTemplate as g, AgentMessageRole as h, AgentConnectionNodeDescriptor as i, NodeBackedToolConfigOptions as j, ChatModelConfig as k, AgentGuardrailConfig as l, AgentMessageLine as m, AgentConnectionCredentialSource as n, McpServerResolver as o, AgentMessageDto as p, CallableToolConfigOptions as q, AgentConnectionNodeCollector as r, AgentAttachmentRole as s, ItemsInputNormalizer as t, AgentGuardrailDefaults as u, AgentModelInvocationOptions as v, AgentToolExecuteArgs as w, AgentToolCall as x, AgentNodeConfig as y, ToolExecuteArgs as z };
//# sourceMappingURL=ItemsInputNormalizer-D2vrMrX1.d.ts.map