@codemation/core-nodes 0.0.19 → 0.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemation/core-nodes",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "publishConfig": {
     "access": "public"
   },
@@ -31,7 +31,7 @@
     "@langchain/core": "^1.1.31",
     "@langchain/openai": "^1.2.12",
     "lucide-react": "^0.577.0",
-    "@codemation/core": "0.0.19"
+    "@codemation/core": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/src/nodes/AIAgentExecutionHelpersFactory.ts

@@ -1,7 +1,10 @@
-import type { CredentialSessionService, Item, Items, NodeExecutionContext } from "@codemation/core";
+import type { CredentialSessionService, Item, Items, NodeExecutionContext, ZodSchemaAny } from "@codemation/core";
 import { injectable } from "@codemation/core";
 
+import { isInteropZodSchema } from "@langchain/core/utils/types";
+import { toJsonSchema } from "@langchain/core/utils/json_schema";
 import { DynamicStructuredTool } from "@langchain/core/tools";
+import { toJSONSchema } from "zod/v4/core";
 
 import { ConnectionCredentialExecutionContextFactory } from "./ConnectionCredentialExecutionContextFactory";
 import type { ResolvedTool } from "./aiAgentSupport.types";
@@ -25,10 +28,19 @@ export class AIAgentExecutionHelpersFactory {
     itemIndex: number,
     items: Items,
   ): DynamicStructuredTool {
+    if (entry.runtime.inputSchema == null) {
+      throw new Error(
+        `Cannot create LangChain tool "${entry.config.name}": missing inputSchema (broken tool runtime resolution).`,
+      );
+    }
+    const schemaForOpenAi = this.normalizeToolInputSchemaForOpenAiDynamicStructuredTool(
+      entry.config.name,
+      entry.runtime.inputSchema,
+    );
     return new DynamicStructuredTool({
       name: entry.config.name,
       description: entry.config.description ?? entry.runtime.defaultDescription,
-      schema: entry.runtime.inputSchema,
+      schema: schemaForOpenAi as unknown as ZodSchemaAny,
       func: async (input) => {
         const result = await entry.runtime.execute({
           config: entry.config,
@@ -42,4 +54,90 @@ export class AIAgentExecutionHelpersFactory {
       },
     });
   }
+
+  /**
+   * 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`.
+   */
+  private normalizeToolInputSchemaForOpenAiDynamicStructuredTool(
+    toolName: string,
+    inputSchema: ZodSchemaAny,
+  ): Record<string, unknown> {
+    const draft07Params = { target: "draft-07" as const };
+    let converted: unknown;
+    if (isInteropZodSchema(inputSchema)) {
+      converted = toJSONSchema(inputSchema as unknown as Parameters<typeof toJSONSchema>[0], draft07Params);
+    } else {
+      converted = toJsonSchema(inputSchema);
+      if (isInteropZodSchema(converted)) {
+        converted = toJSONSchema(inputSchema as unknown as Parameters<typeof toJSONSchema>[0], draft07Params);
+      }
+    }
+    const record = converted as Record<string, unknown>;
+    const { $schema: _draftSchemaOmitted, ...rest } = record;
+    if (rest.type !== "object") {
+      throw new Error(
+        `Cannot create LangChain tool "${toolName}": tool input schema must be a JSON Schema object type (got type=${String(rest.type)}).`,
+      );
+    }
+    if (rest.properties !== undefined && (typeof rest.properties !== "object" || Array.isArray(rest.properties))) {
+      throw new Error(
+        `Cannot create LangChain tool "${toolName}": tool input schema "properties" must be an object (got ${JSON.stringify(rest.properties)}).`,
+      );
+    }
+    if (rest.properties === undefined) {
+      rest.properties = {};
+    }
+    this.sanitizeJsonSchemaRequiredKeywordsForCfworker(rest);
+    return rest;
+  }
+
+  /**
+   * `@cfworker/json-schema` iterates `schema.required` with `for...of`; it must be a string array or absent.
+   */
+  private sanitizeJsonSchemaRequiredKeywordsForCfworker(node: unknown): void {
+    if (!node || typeof node !== "object" || Array.isArray(node)) {
+      return;
+    }
+    const o = node as Record<string, unknown>;
+    const req = o.required;
+    if (req !== undefined && !Array.isArray(req)) {
+      delete o.required;
+    } else if (Array.isArray(req)) {
+      const strings = req.filter((x): x is string => typeof x === "string");
+      if (strings.length === 0) {
+        delete o.required;
+      } else if (strings.length !== req.length) {
+        o.required = strings;
+      }
+    }
+    const props = o.properties;
+    if (props && typeof props === "object" && !Array.isArray(props)) {
+      for (const v of Object.values(props)) {
+        this.sanitizeJsonSchemaRequiredKeywordsForCfworker(v);
+      }
+    }
+    for (const key of ["allOf", "anyOf", "oneOf"] as const) {
+      const branch = o[key];
+      if (Array.isArray(branch)) {
+        for (const sub of branch) {
+          this.sanitizeJsonSchemaRequiredKeywordsForCfworker(sub);
+        }
+      }
+    }
+    if (o.if) this.sanitizeJsonSchemaRequiredKeywordsForCfworker(o.if);
+    if (o.then) this.sanitizeJsonSchemaRequiredKeywordsForCfworker(o.then);
+    if (o.else) this.sanitizeJsonSchemaRequiredKeywordsForCfworker(o.else);
+    if (o.not) this.sanitizeJsonSchemaRequiredKeywordsForCfworker(o.not);
+    if (o.items) this.sanitizeJsonSchemaRequiredKeywordsForCfworker(o.items);
+    if (Array.isArray(o.prefixItems)) {
+      for (const sub of o.prefixItems) {
+        this.sanitizeJsonSchemaRequiredKeywordsForCfworker(sub);
+      }
+    }
+  }
 }

package/src/nodes/AIAgentNode.ts

@@ -477,14 +477,23 @@ export class AIAgentNode implements Node<AIAgent<any, any>> {
   }
 
   private resolveToolRuntime(config: ToolConfig): ResolvedTool["runtime"] {
-    if (config instanceof NodeBackedToolConfig) {
+    if (this.isNodeBackedToolConfig(config)) {
+      const inputSchema = config.getInputSchema();
+      if (inputSchema == null) {
+        throw new Error(
+          `AIAgent tool "${config.name}": node-backed tool is missing inputSchema (cannot build LangChain tool).`,
+        );
+      }
       return {
         defaultDescription: `Run workflow node "${config.node.name ?? config.name}" as an AI tool.`,
-        inputSchema: config.getInputSchema(),
+        inputSchema,
         execute: async (args) => await this.nodeBackedToolRuntime.execute(config, args),
       };
     }
     const tool = this.nodeResolver.resolve(config.type) as Tool<ToolConfig, ZodSchemaAny, ZodSchemaAny>;
+    if (tool.inputSchema == null) {
+      throw new Error(`AIAgent tool "${config.name}": plugin tool "${String(config.type)}" is missing inputSchema.`);
+    }
     return {
       defaultDescription: tool.defaultDescription,
       inputSchema: tool.inputSchema,
@@ -492,6 +501,18 @@ export class AIAgentNode implements Node<AIAgent<any, any>> {
     };
   }
 
+  /**
+   * 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(config: ToolConfig): config is NodeBackedToolConfig<any, any, any> {
+    return (
+      config instanceof NodeBackedToolConfig ||
+      (typeof config === "object" && config !== null && (config as { toolKind?: unknown }).toolKind === "nodeBacked")
+    );
+  }
+
   private resolveGuardrails(guardrails: AgentGuardrailConfig | undefined): ResolvedGuardrails {
     const maxTurns = guardrails?.maxTurns ?? AgentGuardrailDefaults.maxTurns;
     if (!Number.isInteger(maxTurns) || maxTurns < 1) {

package/src/workflows/AIAgentConnectionWorkflowExpander.ts

@@ -1,5 +1,5 @@
 import type { NodeDefinition, WorkflowDefinition, WorkflowNodeConnection } from "@codemation/core";
-import { AgentConfigInspector, ConnectionNodeIdFactory } from "@codemation/core";
+import { AgentConfigInspector, AgentConnectionNodeCollector } from "@codemation/core";
 
 import { AIAgentNode } from "../nodes/AIAgentNode";
 import { ConnectionCredentialNode } from "../nodes/ConnectionCredentialNode";
@@ -12,65 +12,95 @@ export class AIAgentConnectionWorkflowExpander {
   constructor(private readonly connectionCredentialNodeConfigFactory: ConnectionCredentialNodeConfigFactory) {}
 
   expand(workflow: WorkflowDefinition): WorkflowDefinition {
-    const existingByParentAndName = new Map<string, WorkflowNodeConnection>();
-    for (const c of workflow.connections ?? []) {
-      existingByParentAndName.set(`${c.parentNodeId}\0${c.connectionName}`, c);
-    }
-
+    const existingChildIds = this.collectExistingChildIds(workflow);
+    const connectionsByParentAndName = this.createConnectionsByParentAndName(workflow);
     const extraNodes: NodeDefinition[] = [];
-    const extraConnections: WorkflowNodeConnection[] = [];
+    let connectionsChanged = false;
 
     for (const node of workflow.nodes) {
       if (node.type !== AIAgentNode || !AgentConfigInspector.isAgentNodeConfig(node.config)) {
         continue;
       }
-      const agentId = node.id;
-      const agentConfig = node.config;
-
-      if (!existingByParentAndName.has(`${agentId}\0llm`)) {
-        const llmId = ConnectionNodeIdFactory.languageModelConnectionNodeId(agentId);
-        this.assertNoIdCollision(workflow, extraNodes, llmId);
-        extraNodes.push({
-          id: llmId,
-          kind: "node",
-          type: ConnectionCredentialNode,
-          name: agentConfig.chatModel.presentation?.label ?? agentConfig.chatModel.name,
-          config: this.connectionCredentialNodeConfigFactory.create(agentConfig.chatModel.name, agentConfig.chatModel),
-        });
-        extraConnections.push({ parentNodeId: agentId, connectionName: "llm", childNodeIds: [llmId] });
-      }
-
-      if (!existingByParentAndName.has(`${agentId}\0tools`) && (agentConfig.tools?.length ?? 0) > 0) {
-        const toolIds: string[] = [];
-        for (const tool of agentConfig.tools ?? []) {
-          const toolId = ConnectionNodeIdFactory.toolConnectionNodeId(agentId, tool.name);
-          this.assertNoIdCollision(workflow, extraNodes, toolId);
-          toolIds.push(toolId);
+      for (const connectionNode of AgentConnectionNodeCollector.collect(node.id, node.config)) {
+        if (!existingChildIds.has(connectionNode.nodeId)) {
+          this.assertNoIdCollision(workflow, extraNodes, existingChildIds, connectionNode.nodeId);
           extraNodes.push({
-            id: toolId,
+            id: connectionNode.nodeId,
             kind: "node",
             type: ConnectionCredentialNode,
-            name: tool.presentation?.label ?? tool.name,
-            config: this.connectionCredentialNodeConfigFactory.create(tool.name, tool),
+            name: connectionNode.name,
+            config: this.connectionCredentialNodeConfigFactory.create(
+              connectionNode.typeName,
+              connectionNode.credentialSource,
+            ),
           });
         }
-        extraConnections.push({ parentNodeId: agentId, connectionName: "tools", childNodeIds: toolIds });
+        const connectionKey = this.connectionKey(connectionNode.parentNodeId, connectionNode.connectionName);
+        const existingConnection = connectionsByParentAndName.get(connectionKey);
+        if (!existingConnection) {
+          connectionsByParentAndName.set(connectionKey, {
+            parentNodeId: connectionNode.parentNodeId,
+            connectionName: connectionNode.connectionName,
+            childNodeIds: [connectionNode.nodeId],
+          });
+          connectionsChanged = true;
+          continue;
+        }
+        if (!existingConnection.childNodeIds.includes(connectionNode.nodeId)) {
+          connectionsByParentAndName.set(connectionKey, {
+            ...existingConnection,
+            childNodeIds: [...existingConnection.childNodeIds, connectionNode.nodeId],
+          });
+          connectionsChanged = true;
+        }
       }
     }
 
-    if (extraNodes.length === 0) {
+    if (extraNodes.length === 0 && !connectionsChanged) {
       return workflow;
     }
 
     return {
       ...workflow,
       nodes: [...workflow.nodes, ...extraNodes],
-      connections: [...(workflow.connections ?? []), ...extraConnections],
+      connections: [...connectionsByParentAndName.values()],
     };
   }
 
-  private assertNoIdCollision(workflow: WorkflowDefinition, pending: ReadonlyArray<NodeDefinition>, id: string): void {
-    if (workflow.nodes.some((n) => n.id === id) || pending.some((n) => n.id === id)) {
+  private createConnectionsByParentAndName(workflow: WorkflowDefinition): Map<string, WorkflowNodeConnection> {
+    const existingByParentAndName = new Map<string, WorkflowNodeConnection>();
+    for (const connection of workflow.connections ?? []) {
+      existingByParentAndName.set(this.connectionKey(connection.parentNodeId, connection.connectionName), connection);
+    }
+    return existingByParentAndName;
+  }
+
+  private collectExistingChildIds(workflow: WorkflowDefinition): ReadonlySet<string> {
+    const ids = new Set<string>();
+    for (const connection of workflow.connections ?? []) {
+      for (const childId of connection.childNodeIds) {
+        ids.add(childId);
+      }
+    }
+    return ids;
+  }
+
+  private connectionKey(parentNodeId: string, connectionName: string): string {
+    return `${parentNodeId}\0${connectionName}`;
+  }
+
+  private assertNoIdCollision(
+    workflow: WorkflowDefinition,
+    pending: ReadonlyArray<NodeDefinition>,
+    existingChildIds: ReadonlySet<string>,
+    id: string,
+  ): void {
+    if (pending.some((n) => n.id === id)) {
+      throw new Error(
+        `AIAgent connection expansion: node id "${id}" already exists. Rename the conflicting node or adjust the workflow.`,
+      );
+    }
+    if (workflow.nodes.some((n) => n.id === id) && !existingChildIds.has(id)) {
       throw new Error(
         `AIAgent connection expansion: node id "${id}" already exists. Rename the conflicting node or adjust the workflow.`,
       );