@codemation/core-nodes 0.10.1 → 0.12.0

package/src/nodes/DeferredMetaToolStrategy.ts

@@ -1,5 +1,4 @@
 import type { ToolSet } from "ai";
-import { jsonSchema } from "ai";
 import { z } from "zod";
 import type { BM25Index } from "./BM25Index";
 import type {
@@ -37,6 +36,12 @@ export class DeferredMetaToolStrategy implements ToolLoadingStrategy {
   private mcpEntries: McpToolEntry[] = [];
   private toolsByServerId = new Map<string, Map<string, ToolSet[string]>>();
   private foundToolIds = new Set<string>();
+  /**
+   * `jsonSchema` from the `ai` SDK, loaded lazily in {@link initialize} so the SDK
+   * (~28MB RSS) stays off the boot path. `initialize` always runs before the sync
+   * `getToolsForTurn` → `buildFindToolsDefinition` path, so this is set before use.
+   */
+  private jsonSchema!: typeof import("ai").jsonSchema;
 
   constructor(
     private readonly bm25: BM25Index,
@@ -44,6 +49,7 @@ export class DeferredMetaToolStrategy implements ToolLoadingStrategy {
   ) {}
 
   async initialize(input: ToolLoadingStrategyInitInput): Promise<void> {
+    this.jsonSchema = (await import("ai")).jsonSchema;
     this.nodeBackedTools = { ...input.nodeBackedTools };
 
     const pinnedIds = input.pinnedMcpTools ?? [];
@@ -194,7 +200,7 @@ export class DeferredMetaToolStrategy implements ToolLoadingStrategy {
         "After this call, the tools listed in the result will be callable on your very next turn. " +
         "Use this when you need a capability not visible in your current tool list. " +
         "Do not attempt to call a tool name you have not seen yet — use find_tools to discover it first.",
-      inputSchema: jsonSchema(inputSchemaRecord),
+      inputSchema: this.jsonSchema(inputSchemaRecord),
     } as unknown as ToolSet[string];
   }
 }

package/src/nodes/ManualTriggerFactory.ts

@@ -3,6 +3,7 @@ import type { Items, NodeInspectorSummaryRow, TriggerNodeConfig, TypeToken } fro
 import { ItemsInputNormalizer } from "@codemation/core";
 
 import { ManualTriggerNode } from "./ManualTriggerNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 type ManualTriggerDefaultValue<TOutputJson> = Items<TOutputJson> | ReadonlyArray<TOutputJson> | TOutputJson;
 
@@ -13,18 +14,28 @@ export class ManualTrigger<TOutputJson = unknown> implements TriggerNodeConfig<T
   readonly icon = "lucide:play" as const;
   readonly defaultItems?: Items<TOutputJson>;
   readonly id?: string;
+  readonly description?: string;
   /** Manual runs often emit an empty batch; still schedule downstream by default. */
   readonly continueWhenEmptyOutput = true as const;
 
-  constructor(name?: string, id?: string);
-  constructor(name: string, defaultItems: ManualTriggerDefaultValue<TOutputJson>, id?: string);
+  constructor(name?: string, idOrOptions?: string | NodeBaseOptions);
+  constructor(
+    name: string,
+    defaultItems: ManualTriggerDefaultValue<TOutputJson> | undefined,
+    idOrOptions?: string | NodeBaseOptions,
+  );
   constructor(
     public readonly name: string = "Manual trigger",
     defaultItemsOrId?: ManualTriggerDefaultValue<TOutputJson> | string,
-    id?: string,
+    idOrOptions?: string | NodeBaseOptions,
   ) {
+    // Position 2 keeps its existing string-vs-object meaning (string→id, object/array→default items).
+    // Options (id/description) live in the trailing slot, or position 2 when it's a bare string id.
     this.defaultItems = ManualTrigger.resolveDefaultItems(defaultItemsOrId);
-    this.id = ManualTrigger.resolveId(defaultItemsOrId, id);
+    const trailing = idOrOptions ?? (typeof defaultItemsOrId === "string" ? defaultItemsOrId : undefined);
+    const options = typeof trailing === "string" ? { id: trailing } : (trailing ?? {});
+    this.id = options.id;
+    this.description = options.description;
   }
 
   private static resolveDefaultItems<TOutputJson>(
@@ -36,13 +47,6 @@ export class ManualTrigger<TOutputJson = unknown> implements TriggerNodeConfig<T
     return this.itemsInputNormalizer.normalize(value) as Items<TOutputJson>;
   }
 
-  private static resolveId<TOutputJson>(
-    value: ManualTriggerDefaultValue<TOutputJson> | string | undefined,
-    id: string | undefined,
-  ): string | undefined {
-    return typeof value === "string" ? value : id;
-  }
-
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> {
     const rows: NodeInspectorSummaryRow[] = [{ label: "Trigger", value: "manual" }];
     if (this.defaultItems && this.defaultItems.length > 0) {

package/src/nodes/WebhookTriggerFactory.ts

@@ -8,6 +8,7 @@ import type {
 } from "@codemation/core";
 import type { ZodType } from "zod";
 import { WebhookTriggerNode } from "./webhookTriggerNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 type WebhookInputSchema = ZodType<any, any, any>;
 type WebhookTriggerHandler<TConfig extends WebhookTrigger<any> = WebhookTrigger<any>> = (
@@ -21,6 +22,8 @@ export class WebhookTrigger<
   readonly kind = "trigger" as const;
   readonly type: TypeToken<unknown> = WebhookTriggerNode;
   readonly icon = "lucide:globe";
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -32,8 +35,12 @@ export class WebhookTrigger<
     public readonly handler: WebhookTriggerHandler<
       WebhookTrigger<TSchema>
     > = WebhookTrigger.defaultHandler as WebhookTriggerHandler<WebhookTrigger<TSchema>>,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   get endpointKey(): string {
     return this.args.endpointKey;

package/src/nodes/aggregate.ts

@@ -6,6 +6,7 @@ import type {
   TypeToken,
 } from "@codemation/core";
 import { AggregateNode } from "./AggregateNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class Aggregate<TIn = unknown, TOut = unknown> implements RunnableNodeConfig<TIn, TOut> {
   readonly kind = "node" as const;
@@ -13,6 +14,8 @@ export class Aggregate<TIn = unknown, TOut = unknown> implements RunnableNodeCon
   readonly execution = { hint: "local" } as const;
   readonly keepBinaries = true as const;
   readonly icon = "builtin:aggregate-rows" as const;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -20,8 +23,12 @@ export class Aggregate<TIn = unknown, TOut = unknown> implements RunnableNodeCon
       items: Items<TIn>,
       ctx: NodeExecutionContext<Aggregate<TIn, TOut>>,
     ) => TOut | Promise<TOut>,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> | undefined {
     const fnName = this.aggregate.name;

package/src/nodes/assertion.ts

@@ -13,6 +13,7 @@ export interface AssertionOptions<TInputJson> {
   readonly name?: string;
   readonly id?: string;
   readonly icon?: string;
+  readonly description?: string;
   /**
    * Author callback. Returns one or more {@link AssertionResult}s per input item. Each becomes
    * one emitted output item — useful for per-row reporting in the Tests tab. Return `[]` to
@@ -35,6 +36,7 @@ export class Assertion<TInputJson = unknown> implements RunnableNodeConfig<TInpu
   readonly icon: string;
   readonly name: string;
   readonly id?: string;
+  readonly description?: string;
   readonly emitsAssertions = true as const;
   readonly assertions: AssertionOptions<TInputJson>["assertions"];
 
@@ -42,6 +44,7 @@ export class Assertion<TInputJson = unknown> implements RunnableNodeConfig<TInpu
     this.name = options.name ?? "Assertion";
     this.id = options.id;
     this.icon = options.icon ?? "lucide:check-circle";
+    this.description = options.description;
     this.assertions = options.assertions;
   }
 

package/src/nodes/filter.ts

@@ -7,12 +7,15 @@ import type {
   TypeToken,
 } from "@codemation/core";
 import { FilterNode } from "./FilterNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class Filter<TIn = unknown> implements RunnableNodeConfig<TIn, TIn> {
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = FilterNode;
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:filter" as const;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -22,8 +25,12 @@ export class Filter<TIn = unknown> implements RunnableNodeConfig<TIn, TIn> {
       items: Items<TIn>,
       ctx: NodeExecutionContext<Filter<TIn>>,
     ) => boolean,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> | undefined {
     const fnName = this.predicate.name;

package/src/nodes/httpRequest.ts

@@ -62,6 +62,7 @@ export class HttpRequest<
   readonly type: TypeToken<unknown> = HttpRequestNode;
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:globe" as const;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -79,7 +80,7 @@ export class HttpRequest<
       headers?: Readonly<Record<string, string>>;
       /** Query parameters to append to the URL. */
       query?: Readonly<Record<string, string>>;
-      /** Request body specification. For canvas use, pass a JSON string in `body.data`. */
+      /** Request body specification. For `kind:"json"`, pass the object directly in `body.data` — it is JSON-encoded exactly once, so never a pre-stringified string. */
       body?: HttpBodySpec;
       /**
        * Credential slot.
@@ -136,9 +137,13 @@ export class HttpRequest<
        */
       allowedOutboundHosts?: ReadonlyArray<string>;
       id?: string;
+      /** Plain-language explanation surfaced in the node sidebar. */
+      description?: string;
     }> = {},
     public readonly retryPolicy: RetryPolicySpec = RetryPolicy.defaultForHttp,
-  ) {}
+  ) {
+    this.description = args.description;
+  }
 
   get id(): string | undefined {
     return this.args.id;

package/src/nodes/if.ts

@@ -7,6 +7,7 @@ import type {
   TypeToken,
 } from "@codemation/core";
 import { IfNode } from "./IfNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class If<TInputJson = unknown> implements RunnableNodeConfig<TInputJson, TInputJson> {
   readonly kind = "node" as const;
@@ -14,6 +15,8 @@ export class If<TInputJson = unknown> implements RunnableNodeConfig<TInputJson,
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:split@rot=90" as const;
   readonly declaredOutputPorts = ["true", "false"] as const;
+  readonly id?: string;
+  readonly description?: string;
   constructor(
     public readonly name: string,
     public readonly predicate: (
@@ -22,8 +25,12 @@ export class If<TInputJson = unknown> implements RunnableNodeConfig<TInputJson,
       items: Items<TInputJson>,
       ctx: NodeExecutionContext<If<TInputJson>>,
     ) => boolean,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> | undefined {
     const fnName = this.predicate.name;

package/src/nodes/isTestRun.ts

@@ -1,6 +1,7 @@
 import type { RunnableNodeConfig, TypeToken } from "@codemation/core";
 
 import { IsTestRunNode } from "./IsTestRunNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 /**
  * Branches per-item on whether the current run is a test run. Output ports: `true`, `false`.
@@ -14,10 +15,13 @@ export class IsTestRun<TInputJson = unknown> implements RunnableNodeConfig<TInpu
   readonly declaredOutputPorts = ["true", "false"] as const;
   readonly name: string;
   readonly id?: string;
+  readonly description?: string;
 
-  constructor(name: string = "Is test run?", id?: string) {
+  constructor(name: string = "Is test run?", idOrOptions?: string | NodeBaseOptions) {
     this.name = name;
-    this.id = id;
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
   }
 }
 

package/src/nodes/mapData.ts

@@ -6,9 +6,9 @@ import type {
   TypeToken,
 } from "@codemation/core";
 import { MapDataNode } from "./MapDataNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
-export interface MapDataOptions {
-  readonly id?: string;
+export interface MapDataOptions extends NodeBaseOptions {
   readonly keepBinaries?: boolean;
 }
 
@@ -23,6 +23,7 @@ export class MapData<TInputJson = unknown, TOutputJson = unknown> implements Run
   readonly continueWhenEmptyOutput = true as const;
   readonly icon = "lucide:square-pen" as const;
   readonly keepBinaries: boolean;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -33,6 +34,7 @@ export class MapData<TInputJson = unknown, TOutputJson = unknown> implements Run
     private readonly options: MapDataOptions = {},
   ) {
     this.keepBinaries = options.keepBinaries ?? true;
+    this.description = options.description;
   }
 
   get id(): string | undefined {

package/src/nodes/merge.ts

@@ -1,5 +1,6 @@
 import type { InputPortKey, NodeInspectorSummaryRow, RunnableNodeConfig, TypeToken } from "@codemation/core";
 import { MergeNode } from "./MergeNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export type MergeMode = "passThrough" | "append" | "mergeByPosition";
 
@@ -10,6 +11,8 @@ export class Merge<TInputJson = unknown, TOutputJson = TInputJson> implements Ru
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = MergeNode;
   readonly icon = "lucide:merge@rot=90" as const;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -21,8 +24,12 @@ export class Merge<TInputJson = unknown, TOutputJson = TInputJson> implements Ru
        */
       prefer?: ReadonlyArray<InputPortKey>;
     }> = { mode: "passThrough" },
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> {
     const rows: NodeInspectorSummaryRow[] = [{ label: "Mode", value: this.cfg.mode }];

package/src/nodes/noOp.ts

@@ -1,16 +1,23 @@
 import type { RunnableNodeConfig, TypeToken } from "@codemation/core";
 import { NoOpNode } from "./NoOpNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class NoOp<TItemJson = unknown> implements RunnableNodeConfig<TItemJson, TItemJson> {
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = NoOpNode;
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:circle-dashed" as const;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string = "NoOp",
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 }
 
 export { NoOpNode } from "./NoOpNode";

package/src/nodes/nodeOptions.types.ts

@@ -0,0 +1,12 @@
+/**
+ * Options shared by every authorable built-in node: a stable `id` and a plain-language
+ * `description` (the non-technical "what does this node do" line surfaced in the node sidebar).
+ *
+ * `description` is a first-class config option — passed inline in the node's options, exactly like
+ * `id` — and is threaded onto the config instance so it flows into the persisted workflow snapshot
+ * the host / canvas mappers read. Node-specific option types extend this.
+ */
+export interface NodeBaseOptions {
+  readonly id?: string;
+  readonly description?: string;
+}

package/src/nodes/split.ts

@@ -6,6 +6,7 @@ import type {
   TypeToken,
 } from "@codemation/core";
 import { SplitNode } from "./SplitNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class Split<TIn = unknown, TElem = unknown> implements RunnableNodeConfig<TIn, TElem> {
   readonly kind = "node" as const;
@@ -18,12 +19,18 @@ export class Split<TIn = unknown, TElem = unknown> implements RunnableNodeConfig
    */
   readonly continueWhenEmptyOutput = true as const;
   readonly icon = "builtin:split-rows" as const;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
     public readonly getElements: (item: Item<TIn>, ctx: NodeExecutionContext<Split<TIn, TElem>>) => readonly TElem[],
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> | undefined {
     const fnName = this.getElements.name;

package/src/nodes/subWorkflow.ts

@@ -6,6 +6,7 @@ import type {
   UpstreamRefPlaceholder,
 } from "@codemation/core";
 import { SubWorkflowNode } from "./SubWorkflowNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class SubWorkflow<TInputJson = unknown, TOutputJson = unknown> implements RunnableNodeConfig<
   TInputJson,
@@ -14,13 +15,19 @@ export class SubWorkflow<TInputJson = unknown, TOutputJson = unknown> implements
   readonly kind = "node" as const;
   readonly type: TypeToken<unknown> = SubWorkflowNode;
   readonly icon = "lucide:workflow";
+  readonly id?: string;
+  readonly description?: string;
   constructor(
     public readonly name: string,
     public readonly workflowId: string,
     public upstreamRefs?: Array<{ nodeId: NodeId } | UpstreamRefPlaceholder>,
     public readonly startAt?: NodeId,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> {
     const rows: NodeInspectorSummaryRow[] = [{ label: "Workflow", value: this.workflowId }];

package/src/nodes/switch.ts

@@ -7,6 +7,7 @@ import type {
   TypeToken,
 } from "@codemation/core";
 import { SwitchNode } from "./SwitchNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export type SwitchCaseKeyResolver<TInputJson = unknown> = (
   item: Item<TInputJson>,
@@ -21,6 +22,8 @@ export class Switch<TInputJson = unknown> implements RunnableNodeConfig<TInputJs
   readonly execution = { hint: "local" } as const;
   readonly icon = "lucide:git-branch-plus" as const;
   readonly declaredOutputPorts: ReadonlyArray<string>;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
@@ -29,9 +32,12 @@ export class Switch<TInputJson = unknown> implements RunnableNodeConfig<TInputJs
       defaultCase: string;
       resolveCaseKey: SwitchCaseKeyResolver<TInputJson>;
     }>,
-    public readonly id?: string,
+    idOrOptions?: string | NodeBaseOptions,
   ) {
     this.declaredOutputPorts = [...new Set([...cfg.cases, cfg.defaultCase])].sort();
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
   }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> {

package/src/nodes/wait.ts

@@ -1,6 +1,7 @@
 import type { NodeInspectorSummaryRow, RunnableNodeConfig, TypeToken } from "@codemation/core";
 
 import { WaitNode } from "./WaitNode";
+import type { NodeBaseOptions } from "./nodeOptions.types";
 
 export class Wait<TItemJson = unknown> implements RunnableNodeConfig<TItemJson, TItemJson> {
   readonly kind = "node" as const;
@@ -9,12 +10,18 @@ export class Wait<TItemJson = unknown> implements RunnableNodeConfig<TItemJson,
   /** Pass-through empty batches should still advance to downstream nodes. */
   readonly continueWhenEmptyOutput = true as const;
   readonly icon = "lucide:hourglass" as const;
+  readonly id?: string;
+  readonly description?: string;
 
   constructor(
     public readonly name: string,
     public readonly milliseconds: number,
-    public readonly id?: string,
-  ) {}
+    idOrOptions?: string | NodeBaseOptions,
+  ) {
+    const options = typeof idOrOptions === "string" ? { id: idOrOptions } : idOrOptions;
+    this.id = options?.id;
+    this.description = options?.description;
+  }
 
   inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> {
     const seconds = this.milliseconds / 1000;

package/src/workflowAuthoring/WorkflowChatModelFactory.types.ts

@@ -1,6 +1,8 @@
 import type { ChatModelConfig } from "@codemation/core";
 import { OpenAIChatModelConfig } from "../chatModels/openAiChatModelConfig";
-import { CodemationChatModelConfig } from "../chatModels/CodemationChatModelConfig";
+import { CodemationChatModelConfig, type ManagedComplexity } from "../chatModels/CodemationChatModelConfig";
+
+const VALID_COMPLEXITY: ReadonlySet<string> = new Set(["low", "medium", "high", "xhigh"]);
 
 export class WorkflowChatModelFactory {
   static create(model: string | ChatModelConfig): ChatModelConfig {
@@ -9,7 +11,11 @@ export class WorkflowChatModelFactory {
     }
     const [provider, resolvedModel] = model.includes(":") ? model.split(":", 2) : ["openai", model];
     if (provider === "codemation-managed") {
-      return new CodemationChatModelConfig("Codemation Managed", resolvedModel ?? "");
+      const complexity = resolvedModel ?? "medium";
+      if (!VALID_COMPLEXITY.has(complexity)) {
+        throw new Error(`Invalid managed complexity "${complexity}". Must be one of: low, medium, high, xhigh.`);
+      }
+      return new CodemationChatModelConfig("Codemation Managed", complexity as ManagedComplexity);
     }
     if (provider !== "openai") {
       throw new Error(`Unsupported workflow().agent() model provider "${provider}".`);

package/src/chatModels/ManagedModelFetcher.ts

@@ -1,23 +0,0 @@
-import type { ManagedModelDto } from "./CodemationChatModelConfig";
-
-/**
- * Fetches the active platform-managed model allowlist from the CP.
- * Reads CONTROL_PLANE_URL from the workspace process env.
- * Returns an empty array if the env var is absent or the fetch fails.
- * Cache the result per session — the allowlist changes infrequently.
- */
-export class ManagedModelFetcher {
-  async fetch(): Promise<ManagedModelDto[]> {
-    // eslint-disable-next-line no-restricted-properties -- CONTROL_PLANE_URL is injected by the provisioner; this class is the justified boundary.
-    const cpUrl = process.env["CONTROL_PLANE_URL"];
-    if (!cpUrl) return [];
-
-    try {
-      const res = await globalThis.fetch(`${cpUrl}/api/llm/managed-models`);
-      if (!res.ok) return [];
-      return (await res.json()) as ManagedModelDto[];
-    } catch {
-      return [];
-    }
-  }
-}