@codemation/core-nodes 0.4.3 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemation/core-nodes",
-  "version": "0.4.3",
+  "version": "1.0.1",
   "publishConfig": {
     "access": "public"
   },
@@ -28,10 +28,11 @@
     }
   },
   "dependencies": {
-    "@langchain/core": "^1.1.31",
-    "@langchain/openai": "^1.2.12",
+    "@ai-sdk/openai": "^3.0.53",
+    "@ai-sdk/provider": "^3.0.8",
+    "ai": "^6.0.168",
     "lucide-react": "^0.577.0",
-    "@codemation/core": "0.8.1"
+    "@codemation/core": "1.0.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/src/chatModels/OpenAIChatModelFactory.ts

@@ -1,6 +1,8 @@
-import type { ChatModelFactory, LangChainChatModelLike, NodeExecutionContext } from "@codemation/core";
+import type { ChatLanguageModel, ChatModelFactory, NodeExecutionContext } from "@codemation/core";
 import { chatModel } from "@codemation/core";
-import { ChatOpenAI } from "@langchain/openai";
+
+import { createOpenAI } from "@ai-sdk/openai";
+
 import type { OpenAiCredentialSession } from "./OpenAiCredentialSession";
 import type { OpenAIChatModelConfig } from "./openAiChatModelConfig";
 
@@ -8,14 +10,21 @@ import type { OpenAIChatModelConfig } from "./openAiChatModelConfig";
 export class OpenAIChatModelFactory implements ChatModelFactory<OpenAIChatModelConfig> {
   async create(
     args: Readonly<{ config: OpenAIChatModelConfig; ctx: NodeExecutionContext<any> }>,
-  ): Promise<LangChainChatModelLike> {
+  ): Promise<ChatLanguageModel> {
     const session = await args.ctx.getCredential<OpenAiCredentialSession>(args.config.credentialSlotKey);
-    return new ChatOpenAI({
+    const provider = createOpenAI({
       apiKey: session.apiKey,
-      model: args.config.model,
-      temperature: args.config.options?.temperature,
-      maxTokens: args.config.options?.maxTokens,
-      configuration: session.baseUrl ? { baseURL: session.baseUrl } : undefined,
+      baseURL: session.baseUrl,
     });
+    const languageModel = provider.chat(args.config.model);
+    return {
+      languageModel,
+      modelName: args.config.model,
+      provider: "openai",
+      defaultCallOptions: {
+        maxOutputTokens: args.config.options?.maxTokens,
+        temperature: args.config.options?.temperature,
+      },
+    };
   }
 }

package/src/chatModels/OpenAiStrictJsonSchemaFactory.ts

@@ -0,0 +1,123 @@
+import type { ZodSchemaAny } from "@codemation/core";
+import { inject, injectable } from "@codemation/core";
+
+import { AIAgentExecutionHelpersFactory } from "../nodes/AIAgentExecutionHelpersFactory";
+
+/**
+ * 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.
+ */
+@injectable()
+export class OpenAiStrictJsonSchemaFactory {
+  constructor(
+    @inject(AIAgentExecutionHelpersFactory)
+    private readonly executionHelpers: AIAgentExecutionHelpersFactory,
+  ) {}
+
+  createStructuredOutputRecord(
+    schema: ZodSchemaAny,
+    options: Readonly<{ schemaName: string; title?: string }>,
+  ): Record<string, unknown> {
+    const record = this.executionHelpers.createJsonSchemaRecord(schema, {
+      schemaName: options.schemaName,
+      requireObjectRoot: false,
+    });
+    this.strictifyRecursive(record);
+    if (options.title !== undefined) {
+      record.title = options.title;
+    }
+    return record;
+  }
+
+  private strictifyRecursive(node: unknown): void {
+    if (!node || typeof node !== "object" || Array.isArray(node)) {
+      return;
+    }
+    const o = node as Record<string, unknown>;
+    this.stripOpenAiRejectedKeywords(o);
+    if (this.isObjectNode(o)) {
+      const props = this.readPropertiesObject(o);
+      o.properties = props;
+      o.additionalProperties = false;
+      o.required = Object.keys(props);
+      for (const value of Object.values(props)) {
+        this.strictifyRecursive(value);
+      }
+    }
+    this.recurseIntoComposites(o);
+  }
+
+  private stripOpenAiRejectedKeywords(o: Record<string, unknown>): void {
+    delete o["$schema"];
+    delete o["unevaluatedProperties"];
+    delete o["default"];
+  }
+
+  private isObjectNode(o: Record<string, unknown>): boolean {
+    const typeIsObject =
+      o.type === "object" || (Array.isArray(o.type) && (o.type as ReadonlyArray<unknown>).includes("object"));
+    const hasObjectProperties =
+      o.properties !== undefined && typeof o.properties === "object" && !Array.isArray(o.properties);
+    return typeIsObject || hasObjectProperties;
+  }
+
+  private readPropertiesObject(o: Record<string, unknown>): Record<string, unknown> {
+    if (o.properties && typeof o.properties === "object" && !Array.isArray(o.properties)) {
+      return o.properties as Record<string, unknown>;
+    }
+    return {};
+  }
+
+  private recurseIntoComposites(o: Record<string, unknown>): void {
+    for (const key of ["allOf", "anyOf", "oneOf", "prefixItems"] as const) {
+      const branch = o[key];
+      if (Array.isArray(branch)) {
+        for (const sub of branch) {
+          this.strictifyRecursive(sub);
+        }
+      }
+    }
+    if (o.not) {
+      this.strictifyRecursive(o.not);
+    }
+    if (o.items) {
+      if (Array.isArray(o.items)) {
+        for (const sub of o.items) {
+          this.strictifyRecursive(sub);
+        }
+      } else {
+        this.strictifyRecursive(o.items);
+      }
+    }
+    for (const key of ["if", "then", "else"] as const) {
+      if (o[key]) {
+        this.strictifyRecursive(o[key]);
+      }
+    }
+    for (const key of ["$defs", "definitions"] as const) {
+      const defs = o[key];
+      if (defs && typeof defs === "object" && !Array.isArray(defs)) {
+        for (const sub of Object.values(defs as Record<string, unknown>)) {
+          this.strictifyRecursive(sub);
+        }
+      }
+    }
+  }
+}

package/src/index.ts

@@ -1,6 +1,6 @@
 export * from "./canvasIconName";
 export * from "./chatModels/OpenAIChatModelFactory";
-export * from "./chatModels/OpenAIStructuredOutputMethodFactory";
+export * from "./chatModels/OpenAiStrictJsonSchemaFactory";
 export * from "./chatModels/OpenAiCredentialSession";
 export * from "./chatModels/openAiChatModelConfig";
 export * from "./chatModels/OpenAiChatModelPresetsFactory";

package/src/nodes/AIAgentExecutionHelpersFactory.ts

@@ -1,17 +1,30 @@
-import type { CredentialSessionService, Item, Items, NodeExecutionContext, ZodSchemaAny } from "@codemation/core";
+import type { CredentialSessionService, 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 { toJSONSchema as frameworkToJSONSchema } from "zod/v4/core";
 
 import { ConnectionCredentialExecutionContextFactory } from "./ConnectionCredentialExecutionContextFactory";
-import type { ResolvedTool } from "./aiAgentSupport.types";
 
 /**
- * LangChain adapters and credential context wiring for {@link AIAgentNode}.
- * Lives in a `*Factory.ts` composition-root module so construction stays explicit and testable.
+ * Shape of the instance-level `toJSONSchema` method that Zod v4 schemas expose. Conversions must go
+ * through this instance method (see {@link AIAgentExecutionHelpersFactory#createJsonSchemaRecord})
+ * rather than the module-level `toJSONSchema` import because the consumer's workflow-loader (see
+ * `CodemationConsumerConfigLoader.toNamespace`) can load Zod under a separate tsx namespace. That
+ * produces two runtime copies of Zod whose internal class / symbol identities don't overlap, so the
+ * framework-side module-level `toJSONSchema` throws "Cannot read properties of undefined (reading
+ * 'def')" on consumer-created schemas. The instance method is bound inside the schema's own module
+ * and therefore uses the matching Zod internals.
+ */
+type ZodInstanceToJsonSchema = (params?: Readonly<{ target: "draft-07" | "draft-7" | "draft-2020-12" }>) => unknown;
+
+/**
+ * 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).
  */
 @injectable()
 export class AIAgentExecutionHelpersFactory {
@@ -21,47 +34,14 @@ export class AIAgentExecutionHelpersFactory {
     return new ConnectionCredentialExecutionContextFactory(credentialSessions);
   }
 
-  createDynamicStructuredTool(
-    entry: ResolvedTool,
-    toolCredentialContext: NodeExecutionContext<any>,
-    item: Item,
-    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.createJsonSchemaRecord(entry.runtime.inputSchema, {
-      schemaName: entry.config.name,
-      requireObjectRoot: true,
-    });
-    return new DynamicStructuredTool({
-      name: entry.config.name,
-      description: entry.config.description ?? entry.runtime.defaultDescription,
-      schema: schemaForOpenAi as unknown as ZodSchemaAny,
-      func: async (input) => {
-        const result = await entry.runtime.execute({
-          config: entry.config,
-          input,
-          ctx: toolCredentialContext,
-          item,
-          itemIndex,
-          items,
-        });
-        return JSON.stringify(result);
-      },
-    });
-  }
-
   /**
-   * 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`.
+   * 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,
@@ -71,20 +51,12 @@ export class AIAgentExecutionHelpersFactory {
     }>,
   ): 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 converted = this.convertZodSchemaToJsonSchema(inputSchema, draft07Params);
     const record = converted as Record<string, unknown>;
     const { $schema: _draftSchemaOmitted, ...rest } = record;
     if (options.requireObjectRoot && rest.type !== "object") {
       throw new Error(
-        `Cannot create LangChain tool "${options.schemaName}": tool input schema must be a JSON Schema object type (got type=${String(rest.type)}).`,
+        `Cannot create tool "${options.schemaName}": tool input schema must be a JSON Schema object type (got type=${String(rest.type)}).`,
       );
     }
     if (
@@ -93,7 +65,7 @@ export class AIAgentExecutionHelpersFactory {
       (typeof rest.properties !== "object" || Array.isArray(rest.properties))
     ) {
       throw new Error(
-        `Cannot create LangChain tool "${options.schemaName}": tool input schema "properties" must be an object (got ${JSON.stringify(rest.properties)}).`,
+        `Cannot create tool "${options.schemaName}": tool input schema "properties" must be an object (got ${JSON.stringify(rest.properties)}).`,
       );
     }
     if (options.requireObjectRoot && rest.properties === undefined) {
@@ -103,6 +75,20 @@ export class AIAgentExecutionHelpersFactory {
     return rest;
   }
 
+  /**
+   * 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(inputSchema: ZodSchemaAny, params: Readonly<{ target: "draft-07" }>): unknown {
+    const candidate = (inputSchema as unknown as { toJSONSchema?: ZodInstanceToJsonSchema }).toJSONSchema;
+    if (typeof candidate === "function") {
+      return candidate.call(inputSchema, params);
+    }
+    return frameworkToJSONSchema(inputSchema as unknown as Parameters<typeof frameworkToJSONSchema>[0], params);
+  }
+
   /**
    * `@cfworker/json-schema` iterates `schema.required` with `for...of`; it must be a string array or absent.
    */