@codemation/core-nodes 0.4.2 → 1.0.0

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
-import { DynamicStructuredTool } from "@langchain/core/tools";
+import { AssistantModelMessage, ModelMessage, ToolModelMessage } from "ai";
 import { ReadableStream } from "node:stream/web";
 import { DependencyContainer as Container, InjectionToken as TypeToken } from "tsyringe";
 import { ZodType, input, output, z } from "zod";
 
 //#region src/canvasIconName.d.ts
+
 /**
  * Canvas / agent presentation:
  * - Lucide: `lucide:<kebab-name>` or legacy kebab name
@@ -947,25 +947,47 @@ interface ChatModelConfig {
   readonly presentation?: AgentCanvasPresentation;
   getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
 }
-interface LangChainChatModelLike {
-  invoke(input: unknown, options?: unknown): Promise<unknown>;
-  bindTools?(tools: ReadonlyArray<unknown>): LangChainChatModelLike;
-  withStructuredOutput?(outputSchema: ZodSchemaAny, config?: ChatModelStructuredOutputOptions): LangChainStructuredOutputModelLike;
+/**
+ * Provider-neutral chat language model wrapper returned by a {@link ChatModelFactory}.
+ *
+ * Thin adapter around an AI SDK `LanguageModelV2` (from `@ai-sdk/provider`) plus the call-site
+ * defaults Codemation needs at every generate/stream: the provider label, the model name used for
+ * pricing / telemetry, and the default invocation options (max output tokens, temperature,
+ * provider-specific overrides).
+ *
+ * The consumer (AIAgentNode / AgentStructuredOutputRunner) passes `languageModel` directly into
+ * `generateText({ model, ... })` from the `ai` package.
+ */
+interface ChatLanguageModel {
+  /** AI SDK `LanguageModelV2` instance (kept `unknown` to avoid leaking the SDK type into `@codemation/core`). */
+  readonly languageModel: unknown;
+  /** Stable pricing/telemetry key — e.g. `"gpt-4.1-nano"`. */
+  readonly modelName: string;
+  /** Provider label — e.g. `"openai"`. Used for cost tracking. */
+  readonly provider?: string;
+  /** Defaults merged into every call. Consumers may override per-invocation. */
+  readonly defaultCallOptions?: ChatLanguageModelCallOptions;
 }
-interface LangChainStructuredOutputModelLike {
-  invoke(input: unknown, options?: unknown): Promise<unknown>;
+interface ChatLanguageModelCallOptions {
+  readonly maxOutputTokens?: number;
+  readonly temperature?: number;
+  readonly providerOptions?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
 }
-interface ChatModelStructuredOutputOptions {
-  readonly method?: "jsonSchema" | "functionCalling" | "jsonMode";
+/**
+ * Options for a structured-output generate call. Mirrors
+ * `generateText({ output: Output.object(...) })` from the `ai` package.
+ */
+interface StructuredOutputOptions {
+  /** Optional schema name — used by some providers as the JSON schema name attribute. */
+  readonly schemaName?: string;
+  /** When `true`, the consumer should pass a strict-mode-compatible JSON Schema record. */
   readonly strict?: boolean;
-  readonly includeRaw?: boolean;
-  readonly tools?: ReadonlyArray<unknown>;
 }
 interface ChatModelFactory<TConfig extends ChatModelConfig = ChatModelConfig> {
   create(args: Readonly<{
     config: TConfig;
     ctx: NodeExecutionContext<any>;
-  }>): Promise<LangChainChatModelLike> | LangChainChatModelLike;
+  }>): Promise<ChatLanguageModel> | ChatLanguageModel;
 }
 type NodeBackedToolInputMapperArgs<TNodeConfig extends RunnableNodeConfig<any, any>, TToolInput = unknown> = Readonly<{
   input: TToolInput;
@@ -1058,16 +1080,96 @@ declare class OpenAIChatModelFactory implements ChatModelFactory<OpenAIChatModel
   create(args: Readonly<{
     config: OpenAIChatModelConfig;
     ctx: NodeExecutionContext<any>;
-  }>): Promise<LangChainChatModelLike>;
+  }>): Promise<ChatLanguageModel>;
 }
 //#endregion
-//#region src/chatModels/OpenAIStructuredOutputMethodFactory.d.ts
-declare class OpenAIStructuredOutputMethodFactory {
-  private static readonly isoDatePattern;
-  create(chatModelConfig: ChatModelConfig): ChatModelStructuredOutputOptions | undefined;
-  private readModelName;
-  private supportsJsonSchema;
-  private supportsSnapshotAtOrAfter;
+//#region src/nodes/ConnectionCredentialExecutionContextFactory.d.ts
+/**
+ * Builds a {@link NodeExecutionContext} whose identity for credential binding and `getCredential`
+ * is a **connection-owned** workflow node id (`ConnectionNodeIdFactory` in `@codemation/core`),
+ * not the executing parent node. Use for LLM slots, tool slots, or any connection-scoped owner.
+ */
+declare class ConnectionCredentialExecutionContextFactory {
+  private readonly credentialResolverFactory;
+  constructor(credentialSessions: CredentialSessionService);
+  forConnectionNode<TConfig extends NodeConfigBase>(ctx: NodeExecutionContext<TConfig>, args: Readonly<{
+    connectionNodeId: NodeId;
+    getCredentialRequirements: () => ReadonlyArray<CredentialRequirement>;
+  }>): NodeExecutionContext<TConfig>;
+}
+//#endregion
+//#region src/nodes/AIAgentExecutionHelpersFactory.d.ts
+/**
+ * Helper utilities shared by {@link AIAgentNode} and supporting runners.
+ *
+ * Responsibilities:
+ * - {@link #createConnectionCredentialExecutionContextFactory} centralizes credential-context wiring.
+ * - {@link #createJsonSchemaRecord} is a pure Zod → draft-07 converter used by both
+ *   `OpenAiStrictJsonSchemaFactory` (to feed OpenAI-strict structured output) and the
+ *   `AgentStructuredOutputRepairPromptFactory` (to show a required-schema reminder).
+ */
+declare class AIAgentExecutionHelpersFactory {
+  createConnectionCredentialExecutionContextFactory(credentialSessions: CredentialSessionService): ConnectionCredentialExecutionContextFactory;
+  /**
+   * Produces a plain JSON Schema object (`draft-07`) from a Zod schema, as needed by
+   * OpenAI tool-parameter schemas and the structured-output repair prompt.
+   * - Prefers the schema's **instance** `toJSONSchema(...)` method so we stay inside the Zod
+   *   instance that created the schema (works across consumer/framework tsx namespaces — see
+   *   {@link ZodInstanceToJsonSchema}). Falls back to the framework-imported module function.
+   * - Strips root `$schema` (OpenAI ignores it).
+   * - Sanitizes `required` for cfworker json-schema compatibility (must be a string array or absent).
+   */
+  createJsonSchemaRecord(inputSchema: ZodSchemaAny, options: Readonly<{
+    schemaName: string;
+    requireObjectRoot: boolean;
+  }>): Record<string, unknown>;
+  /**
+   * Runs Zod's `toJSONSchema` via the schema's own instance method when available, so consumer
+   * schemas loaded under a different tsx namespace still convert correctly. If the caller handed us
+   * a payload that lacks that method (e.g. a plain JSON Schema record or a Zod instance whose
+   * prototype was stripped), we fall back to the framework-bundled module function.
+   */
+  private convertZodSchemaToJsonSchema;
+  /**
+   * `@cfworker/json-schema` iterates `schema.required` with `for...of`; it must be a string array or absent.
+   */
+  private sanitizeJsonSchemaRequiredKeywordsForCfworker;
+}
+//#endregion
+//#region src/chatModels/OpenAiStrictJsonSchemaFactory.d.ts
+/**
+ * Produces an OpenAI **strict mode**–compliant JSON Schema for an AIAgent `outputSchema`.
+ *
+ * Why this exists: AI SDK's default Zod → JSON Schema conversion (Zod v4's `toJSONSchema`) can
+ * emit `unevaluatedProperties: false` or skip `additionalProperties: false` on object branches.
+ * OpenAI's strict-mode validator rejects anything missing `additionalProperties: false` at
+ * `context=()` (the root) and requires **all properties** in `required`. We convert here so all
+ * legal Zod root shapes work (object, union, discriminated union, nullable-object wrapper, array,
+ * intersection, …) and hand AI SDK a pre-tagged `jsonSchema(...)` record that passes straight
+ * through to the provider.
+ *
+ * Rules enforced on the produced JSON Schema record:
+ * - Every `type: "object"` node (root and nested under `allOf`/`anyOf`/`oneOf`/`items`/`prefixItems`/`$defs`):
+ *   - `additionalProperties: false`
+ *   - `required` lists **every** key in `properties` (OpenAI strict requires all properties required;
+ *     express optionality via `.nullable()` / `z.union([..., z.null()])`).
+ *   - `properties` is always an object (empty object allowed).
+ * - `$schema`, `unevaluatedProperties`, and `default` are stripped (OpenAI rejects / ignores them).
+ * - `sanitizeJsonSchemaRequiredKeywordsForCfworker` invariants from
+ *   {@link AIAgentExecutionHelpersFactory.createJsonSchemaRecord} are preserved as a starting point.
+ */
+declare class OpenAiStrictJsonSchemaFactory {
+  private readonly executionHelpers;
+  constructor(executionHelpers: AIAgentExecutionHelpersFactory);
+  createStructuredOutputRecord(schema: ZodSchemaAny, options: Readonly<{
+    schemaName: string;
+    title?: string;
+  }>): Record<string, unknown>;
+  private strictifyRecursive;
+  private stripOpenAiRejectedKeywords;
+  private isObjectNode;
+  private readPropertiesObject;
+  private recurseIntoComposites;
 }
 //#endregion
 //#region src/chatModels/OpenAiCredentialSession.d.ts
@@ -1089,41 +1191,6 @@ declare class OpenAiChatModelPresets {
 }
 declare const openAiChatModelPresets: OpenAiChatModelPresets;
 //#endregion
-//#region src/nodes/AgentMessageFactory.d.ts
-declare class AgentMessageFactory {
-  static createPromptMessages(messages: ReadonlyArray<AgentMessageDto>): ReadonlyArray<BaseMessage>;
-  static createSystemPrompt(systemMessage: string): SystemMessage;
-  static createUserPrompt(prompt: string): HumanMessage;
-  static createAssistantPrompt(prompt: string): AIMessage;
-  static createToolMessage(toolCallId: string, content: string): ToolMessage;
-  static extractContent(message: unknown): string;
-  static extractToolCalls(message: unknown): ReadonlyArray<AgentToolCall>;
-  private static isRecord;
-  private static createPromptMessage;
-}
-//#endregion
-//#region src/nodes/AgentOutputFactory.d.ts
-declare class AgentOutputFactory {
-  static fromUnknown(value: unknown): NodeOutputs;
-  static replaceJson(item: Item, value: unknown): Item;
-  static fromAgentContent(content: string): unknown;
-}
-//#endregion
-//#region src/nodes/ConnectionCredentialExecutionContextFactory.d.ts
-/**
- * Builds a {@link NodeExecutionContext} whose identity for credential binding and `getCredential`
- * is a **connection-owned** workflow node id (`ConnectionNodeIdFactory` in `@codemation/core`),
- * not the executing parent node. Use for LLM slots, tool slots, or any connection-scoped owner.
- */
-declare class ConnectionCredentialExecutionContextFactory {
-  private readonly credentialResolverFactory;
-  constructor(credentialSessions: CredentialSessionService);
-  forConnectionNode<TConfig extends NodeConfigBase>(ctx: NodeExecutionContext<TConfig>, args: Readonly<{
-    connectionNodeId: NodeId;
-    getCredentialRequirements: () => ReadonlyArray<CredentialRequirement>;
-  }>): NodeExecutionContext<TConfig>;
-}
-//#endregion
 //#region src/nodes/aiAgentSupport.types.d.ts
 declare class AgentItemPortMap {
   static fromItem(item: Item): NodeInputsByPort;
@@ -1136,9 +1203,15 @@ type ResolvedTool = Readonly<{
     execute(args: ToolExecuteArgs<ToolConfig, unknown>): Promise<unknown>;
   }>;
 }>;
+/**
+ * Per-item binding of a tool: the user config plus the resolved runtime and a snapshot of the
+ * original Zod `inputSchema` used to convert to AI SDK `Tool` + OpenAI-strict JSON Schema for
+ * repair prompts.
+ */
 type ItemScopedToolBinding = Readonly<{
   config: ToolConfig;
-  langChainTool: DynamicStructuredTool;
+  inputSchema: ZodSchemaAny;
+  execute(input: unknown): Promise<unknown>;
 }>;
 type PlannedToolCall = Readonly<{
   binding: ItemScopedToolBinding;
@@ -1153,30 +1226,33 @@ type ExecutedToolCall = Readonly<{
   serialized: string;
 }>;
 //#endregion
-//#region src/nodes/AIAgentExecutionHelpersFactory.d.ts
+//#region src/nodes/AgentMessageFactory.d.ts
 /**
- * LangChain adapters and credential context wiring for {@link AIAgentNode}.
- * Lives in a `*Factory.ts` composition-root module so construction stays explicit and testable.
+ * AI-SDK-shaped message construction for the AIAgent stack. Emits plain `ModelMessage[]`
+ * ( `{ role: 'system' | 'user' | 'assistant' | 'tool', content: ... }` ) as consumed by
+ * `generateText({ messages })` from the `ai` package.
  */
-declare class AIAgentExecutionHelpersFactory {
-  createConnectionCredentialExecutionContextFactory(credentialSessions: CredentialSessionService): ConnectionCredentialExecutionContextFactory;
-  createDynamicStructuredTool(entry: ResolvedTool, toolCredentialContext: NodeExecutionContext<any>, item: Item, itemIndex: number, items: Items): DynamicStructuredTool;
+declare class AgentMessageFactory {
+  static createPromptMessages(messages: ReadonlyArray<AgentMessageDto>): ReadonlyArray<ModelMessage>;
   /**
-   * Produces a plain JSON Schema object for OpenAI tool parameters and LangChain tool invocation:
-   * - **Zod** → `toJSONSchema(..., { target: "draft-07" })` so shapes match what `@cfworker/json-schema`
-   *   expects (`required` must be an array; draft 2020-12 output can break validation).
-   * - Otherwise LangChain `toJsonSchema` (Standard Schema + JSON passthrough); if the result is still Zod
-   *   (duplicate `zod` copies), fall back to Zod `toJSONSchema` with draft-07.
-   * - Strip root `$schema` for OpenAI; normalize invalid `required` keywords for cfworker; ensure `properties`.
+   * Builds the assistant message that contains optional text plus one or more tool-call parts,
+   * matching the shape AI SDK emits between steps.
    */
-  createJsonSchemaRecord(inputSchema: ZodSchemaAny, options: Readonly<{
-    schemaName: string;
-    requireObjectRoot: boolean;
-  }>): Record<string, unknown>;
+  static createAssistantWithToolCalls(text: string | undefined, toolCalls: ReadonlyArray<AgentToolCall>): AssistantModelMessage;
   /**
-   * `@cfworker/json-schema` iterates `schema.required` with `for...of`; it must be a string array or absent.
+   * Builds the `{ role: "tool", content: [{ type: "tool-result", ... }, ...] }` message returned
+   * to the model after each tool round.
    */
-  private sanitizeJsonSchemaRequiredKeywordsForCfworker;
+  static createToolResultsMessage(executedToolCalls: ReadonlyArray<ExecutedToolCall>): ToolModelMessage;
+  private static toToolResultJson;
+  private static createPromptMessage;
+}
+//#endregion
+//#region src/nodes/AgentOutputFactory.d.ts
+declare class AgentOutputFactory {
+  static fromUnknown(value: unknown): NodeOutputs;
+  static replaceJson(item: Item, value: unknown): Item;
+  static fromAgentContent(content: string): unknown;
 }
 //#endregion
 //#region src/nodes/AgentStructuredOutputRepairPromptFactory.d.ts
@@ -1195,26 +1271,46 @@ declare class AgentStructuredOutputRepairPromptFactory {
 }
 //#endregion
 //#region src/nodes/AgentStructuredOutputRunner.d.ts
+type StructuredOutputSchemaForModel = ZodSchemaAny | Readonly<Record<string, unknown>>;
+/**
+ * Orchestrates a 2-attempt repair loop on top of `generateText({ output: Output.object(...) })`.
+ *
+ * Strategy:
+ * 1. If the caller already has a raw final text (from a prior tool-calling turn), try parsing it
+ *    directly against the schema — fast path for models that already emit strict JSON.
+ * 2. Otherwise, run a native structured-output call via {@link invokeStructuredModel}. For the
+ *    OpenAI-strict path, a {@link OpenAiStrictJsonSchemaFactory}-built JSON Schema record is
+ *    handed to AI SDK's `jsonSchema(...)` wrapper (preserves `additionalProperties: false` at
+ *    every object depth).
+ * 3. If the structured call fails (AI_NoObjectGeneratedError / ZodError / schema reject), run a
+ *    text-mode repair prompt with the validation error appended, up to 2 attempts.
+ */
 declare class AgentStructuredOutputRunner {
   private readonly repairPromptFactory;
-  private readonly openAiStructuredOutputMethodFactory;
+  private readonly openAiStrictJsonSchemaFactory;
   private static readonly repairAttemptCount;
-  constructor(repairPromptFactory: AgentStructuredOutputRepairPromptFactory, openAiStructuredOutputMethodFactory: OpenAIStructuredOutputMethodFactory);
+  private static readonly structuredOutputSchemaName;
+  constructor(repairPromptFactory: AgentStructuredOutputRepairPromptFactory, openAiStrictJsonSchemaFactory: OpenAiStrictJsonSchemaFactory);
   resolve<TOutput>(args: Readonly<{
-    model: LangChainChatModelLike;
+    model: ChatLanguageModel;
     chatModelConfig: ChatModelConfig;
     schema: ZodSchemaAny;
-    conversation: ReadonlyArray<BaseMessage>;
-    rawFinalResponse?: AIMessage;
+    conversation: ReadonlyArray<ModelMessage>;
+    rawFinalText?: string;
     agentName: string;
     nodeId: string;
-    invokeTextModel: (messages: ReadonlyArray<BaseMessage>) => Promise<AIMessage>;
-    invokeStructuredModel: (model: LangChainStructuredOutputModelLike, messages: ReadonlyArray<BaseMessage>) => Promise<unknown>;
+    invokeTextModel: (messages: ReadonlyArray<ModelMessage>) => Promise<{
+      text: string;
+    }>;
+    invokeStructuredModel: (schema: StructuredOutputSchemaForModel, messages: ReadonlyArray<ModelMessage>, options: StructuredOutputOptions | undefined) => Promise<unknown>;
   }>): Promise<TOutput>;
   private retryWithRepairPrompt;
-  private createStructuredOutputModel;
-  private getStructuredOutputOptions;
-  private supportsNativeStructuredOutput;
+  /**
+   * Chooses strict mode for OpenAI chat-model configs, off otherwise.  Extendable in future for
+   * other providers that adopt the same "supply a JSON Schema record directly" contract.
+   */
+  private resolveStructuredOutputOptions;
+  private resolveOutputSchemaForModel;
   private tryParseAndValidate;
   private tryValidateStructuredValue;
   private summarizeError;
@@ -1321,7 +1417,6 @@ declare class AgentToolExecutionCoordinator {
   private createRepairPayload;
   private createRepairDetails;
   private createValidationMessage;
-  private parseToolOutput;
   private toJsonValue;
   private extractErrorDetails;
   private serializeIssue;
@@ -1363,28 +1458,21 @@ declare class AIAgentNode implements RunnableNode<AIAgent<any, any>> {
   private readonly toolExecutionCoordinator;
   kind: "node";
   outputPorts: readonly ["main"];
-  /**
-   * Engine validates {@link RunnableNodeConfig.inputSchema} (Zod) on {@code item.json} before enqueue, then resolves
-   * per-item **`itemExpr`** leaves on config before {@link #execute}. Prefer modeling prompts as
-   * {@code { messages: [{ role, content }, ...] }} (on input or config) so persisted inputs are visible in the UI.
-   */
   readonly inputSchema: z.ZodUnknown;
   private readonly connectionCredentialExecutionContextFactory;
-  /** One resolved model/tools bundle per activation context (same ctx across items in a batch). */
   private readonly preparedByExecutionContext;
   constructor(nodeResolver: NodeResolver, credentialSessions: CredentialSessionService, nodeBackedToolRuntime: NodeBackedToolRuntime, executionHelpers: AIAgentExecutionHelpersFactory, structuredOutputRunner: AgentStructuredOutputRunner, toolExecutionCoordinator: AgentToolExecutionCoordinator);
   execute(args: RunnableNodeExecuteArgs<AIAgent<any, any>>): Promise<unknown>;
   private getOrPrepareExecution;
-  /**
-   * Resolves the chat model and tools once per activation, then reuses for every item in the batch.
-   */
   private prepareExecution;
-  /**
-   * One item: build prompts, optionally bind tools, run the multi-turn loop, map the final model message to workflow JSON.
-   */
   private runAgentForItem;
   /**
-   * Repeatedly invokes the model until it returns without tool calls, or guardrails end the loop.
+   * Multi-turn loop:
+   * - Each turn is a single `generateText` call with tools exposed but **not auto-executed**
+   *   (we control tool dispatch so that {@link AgentToolExecutionCoordinator} drives repair /
+   *   connection-invocation recording / transient-error handling exactly like before).
+   * - When the model returns no tool calls the loop ends with the model's text as the final answer.
+   * - Respects `guardrails.maxTurns` and `guardrails.onTurnLimitReached`.
    */
   private runTurnLoopUntilFinalAnswer;
   private cannotExecuteAnotherToolRound;
@@ -1392,20 +1480,44 @@ declare class AIAgentNode implements RunnableNode<AIAgent<any, any>> {
   private appendAssistantAndToolMessages;
   private resolveFinalOutputJson;
   private buildOutputItem;
-  private bindToolsToModel;
   private resolveTools;
   private createItemScopedTools;
-  private invokeModel;
-  private invokeStructuredModel;
+  /**
+   * Builds an AI SDK {@link ToolSet} where every tool ships a pre-converted JSON Schema (via
+   * {@link jsonSchema}) — not the raw Zod schema — and carries **no** `execute`. Two reasons:
+   *
+   * 1. Codemation owns tool dispatch + the per-tool repair loop (see {@link AgentToolExecutionCoordinator}),
+   *    so the AI SDK must surface tool calls back to us instead of auto-running them.
+   * 2. The AI SDK's `asSchema` helper discriminates between Zod v3 / Zod v4 / Standard Schema via
+   *    runtime feature-detection (`~standard`, `_zod`, etc.). Handing it a pre-built
+   *    {@link jsonSchema} record — which is tagged with `Symbol.for('vercel.ai.schema')` — skips all
+   *    of that detection and guarantees the provider receives a draft-07 JSON Schema with
+   *    `additionalProperties: false` at every object depth (see {@link OpenAiStrictJsonSchemaFactory}
+   *    for the same logic applied to structured-output schemas). Codemation still runs its own Zod
+   *    validation on tool inputs before execute — the schema handed to the model is advisory.
+   */
+  private buildToolSet;
+  /**
+   * One `generateText` turn (no auto tool execution) with Codemation-owned child-span telemetry
+   * and connection-invocation state recording.
+   */
+  private invokeTextTurn;
+  /**
+   * Structured-output turn: runs `generateText({ output: Output.object({ schema }) })` via the
+   * structured-output runner.  We keep this as a separate helper because the runner needs the raw
+   * validated value (not just text) back, and must be able to retry on Zod failures.
+   */
+  private invokeStructuredTurn;
+  private isZodSchema;
+  private resolveCallOptions;
+  private extractTurnResult;
+  private extractAssistantMessage;
+  private extractUsageFromResult;
+  private toFiniteNumber;
   private createModelInvocationSpan;
   private recordModelUsageMetrics;
   private captureCostTrackingUsage;
   private resolveChatModelName;
-  private extractModelUsageMetrics;
-  private extractUsageObject;
-  private readUsageNumber;
-  private readNestedUsageValue;
-  private isRecord;
   private markQueuedTools;
   private planToolCalls;
   private failTrackedNodeInvocation;
@@ -1413,15 +1525,7 @@ declare class AIAgentNode implements RunnableNode<AIAgent<any, any>> {
   private resultToJsonValue;
   private createPromptMessages;
   private resolveToolRuntime;
-  /**
-   * Consumer apps can resolve two copies of `@codemation/core`, breaking `instanceof NodeBackedToolConfig` and
-   * sending node-backed tools down the plugin-tool branch with `inputSchema: undefined` (LangChain then crashes in
-   * json-schema validation). {@link NodeBackedToolConfig#toolKind} is stable across copies.
-   */
   private isNodeBackedToolConfig;
-  /**
-   * Callable tools use {@link CallableToolConfig#toolKind} for cross-package / JSON round-trip safety.
-   */
   private isCallableToolConfig;
   private resolveGuardrails;
   private getAgentDisplayName;
@@ -2030,5 +2134,5 @@ declare class AIAgentConnectionWorkflowExpander {
   private assertNoIdCollision;
 }
 //#endregion
-export { AIAgent, AIAgentConnectionWorkflowExpander, AIAgentExecutionHelpersFactory, AIAgentNode, AgentItemPortMap, AgentMessageFactory, AgentOutputFactory, AgentStructuredOutputRepairPromptFactory, AgentStructuredOutputRunner, AgentToolCallPortMap, AgentToolErrorClassifier, AgentToolExecutionCoordinator, AgentToolRepairExhaustedError, AgentToolRepairPolicy, Aggregate, AggregateNode, Callback, CallbackHandler, CallbackNode, CallbackOptions, CallbackResultNormalizer, CanvasIconName, ConnectionCredentialExecutionContextFactory, ConnectionCredentialNode, ConnectionCredentialNodeConfig, ConnectionCredentialNodeConfigFactory, type ExecutedToolCall, Filter, FilterNode, HttpRequest, HttpRequestDownloadMode, HttpRequestNode, HttpRequestOutputJson, If, IfNode, type ItemScopedToolBinding, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, MapDataOptions, Merge, MergeMode, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAIStructuredOutputMethodFactory, OpenAiChatModelPresets, OpenAiCredentialSession, type PlannedToolCall, type ResolvedTool, Split, SplitNode, SubWorkflow, SubWorkflowNode, Switch, SwitchCaseKeyResolver, SwitchNode, Wait, WaitDuration, WaitNode, WebhookRespondNowAndContinueError, WebhookRespondNowError, WebhookTrigger, WebhookTriggerNode, type WorkflowAgentMessages, type WorkflowAgentOptions, WorkflowAuthoringBuilder, WorkflowBranchBuilder, WorkflowChain, createWorkflowBuilder, openAiChatModelPresets, registerCoreNodes, workflow };
+export { AIAgent, AIAgentConnectionWorkflowExpander, AIAgentExecutionHelpersFactory, AIAgentNode, AgentItemPortMap, AgentMessageFactory, AgentOutputFactory, AgentStructuredOutputRepairPromptFactory, AgentStructuredOutputRunner, AgentToolCallPortMap, AgentToolErrorClassifier, AgentToolExecutionCoordinator, AgentToolRepairExhaustedError, AgentToolRepairPolicy, Aggregate, AggregateNode, Callback, CallbackHandler, CallbackNode, CallbackOptions, CallbackResultNormalizer, CanvasIconName, ConnectionCredentialExecutionContextFactory, ConnectionCredentialNode, ConnectionCredentialNodeConfig, ConnectionCredentialNodeConfigFactory, type ExecutedToolCall, Filter, FilterNode, HttpRequest, HttpRequestDownloadMode, HttpRequestNode, HttpRequestOutputJson, If, IfNode, type ItemScopedToolBinding, ManualTrigger, ManualTriggerNode, MapData, MapDataNode, MapDataOptions, Merge, MergeMode, MergeNode, NoOp, NoOpNode, OpenAIChatModelConfig, OpenAIChatModelFactory, OpenAiChatModelPresets, OpenAiCredentialSession, OpenAiStrictJsonSchemaFactory, type PlannedToolCall, type ResolvedTool, Split, SplitNode, SubWorkflow, SubWorkflowNode, Switch, SwitchCaseKeyResolver, SwitchNode, Wait, WaitDuration, WaitNode, WebhookRespondNowAndContinueError, WebhookRespondNowError, WebhookTrigger, WebhookTriggerNode, type WorkflowAgentMessages, type WorkflowAgentOptions, WorkflowAuthoringBuilder, WorkflowBranchBuilder, WorkflowChain, createWorkflowBuilder, openAiChatModelPresets, registerCoreNodes, workflow };
 //# sourceMappingURL=index.d.ts.map