@codemation/core-nodes 1.0.1 → 1.1.0

package/src/nodes/HttpRequestNodeFactory.ts

@@ -1,7 +1,10 @@
 import type { Item, NodeExecutionContext, RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
 
 import { node } from "@codemation/core";
-
+import type { CredentialSession, HttpRequestSpec } from "../http/httpRequest.types";
+import { HttpRequestExecutor } from "../http/HttpRequestExecutor";
+import { HttpBodyBuilder } from "../http/HttpBodyBuilder";
+import { HttpUrlBuilder } from "../http/HttpUrlBuilder";
 import type { HttpRequestDownloadMode } from "./httpRequest";
 import { HttpRequest } from "./httpRequest";
 
@@ -16,44 +19,113 @@ export class HttpRequestNode implements RunnableNode<HttpRequest<any, any>> {
 
   private async executeItem(item: Item, ctx: NodeExecutionContext<HttpRequest<any, any>>): Promise<Item> {
     const url = this.resolveUrl(item, ctx);
-    const response = await fetch(url, {
+    const credential = await this.resolveCredential(ctx);
+
+    const spec: HttpRequestSpec = {
+      url,
       method: ctx.config.method,
-    });
+      headers: ctx.config.args.headers,
+      query: ctx.config.args.query,
+      body: ctx.config.args.body,
+      credential,
+      download: {
+        mode: ctx.config.downloadMode,
+        binaryName: ctx.config.binaryName,
+      },
+      ctx: ctx as unknown as HttpRequestSpec["ctx"],
+    };
+
+    // Build the request (headers, body encoding, URL query merge) once,
+    // then make a SINGLE fetch call and decide what to do with the response.
+    // This avoids a double-fetch regression for auto-mode binary responses.
+    const executor = new HttpRequestExecutor(globalThis.fetch, new HttpBodyBuilder(), new HttpUrlBuilder());
+    const { url: resolvedUrl, init } = await executor.buildRequest(spec, item);
+
+    const response = await globalThis.fetch(resolvedUrl, init);
+
     const headers = this.readHeaders(response.headers);
     const mimeType = this.resolveMimeType(headers);
-    const bodyBinaryName = ctx.config.binaryName;
-    const shouldAttachBody = this.shouldAttachBody(ctx.config.downloadMode, mimeType);
+    const binaryName = ctx.config.binaryName;
+    const shouldAttach = this.shouldAttachBody(ctx.config.downloadMode, mimeType);
+
+    if (shouldAttach) {
+      const outputJson: Readonly<Record<string, unknown>> = {
+        url: resolvedUrl,
+        method: ctx.config.method,
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        mimeType,
+        headers,
+        bodyBinaryName: binaryName,
+      };
+
+      const attachment = await ctx.binary.attach({
+        name: binaryName,
+        body: response.body
+          ? (response.body as unknown as Parameters<typeof ctx.binary.attach>[0]["body"])
+          : new Uint8Array(await response.arrayBuffer()),
+        mimeType,
+        filename: this.resolveFilename(resolvedUrl, headers),
+      });
+
+      let outputItem: Item = { json: outputJson };
+      outputItem = ctx.binary.withAttachment(outputItem, binaryName, attachment);
+      return outputItem;
+    }
+
+    // Non-binary path: parse JSON or read text.
+    const isJson = this.isJsonMimeType(mimeType);
+    let json: unknown | undefined;
+    let text: string | undefined;
+
+    if (isJson) {
+      try {
+        json = await response.json();
+      } catch {
+        text = await response.text();
+      }
+    } else {
+      text = await response.text();
+    }
+
     const outputJson: Readonly<Record<string, unknown>> = {
-      url,
+      url: resolvedUrl,
       method: ctx.config.method,
       ok: response.ok,
       status: response.status,
       statusText: response.statusText,
       mimeType,
       headers,
-      ...(shouldAttachBody ? { bodyBinaryName } : {}),
+      ...(json !== undefined ? { json } : {}),
+      ...(text !== undefined ? { text } : {}),
     };
 
-    let outputItem: Item = {
-      json: outputJson,
-    };
-    if (!shouldAttachBody) {
-      return outputItem;
-    }
+    return { json: outputJson };
+  }
 
-    const attachment = await ctx.binary.attach({
-      name: bodyBinaryName,
-      body: response.body
-        ? (response.body as unknown as Parameters<typeof ctx.binary.attach>[0]["body"])
-        : new Uint8Array(await response.arrayBuffer()),
-      mimeType,
-      filename: this.resolveFilename(url, headers),
-    });
-    outputItem = ctx.binary.withAttachment(outputItem, bodyBinaryName, attachment);
-    return outputItem;
+  private async resolveCredential(
+    ctx: NodeExecutionContext<HttpRequest<any, any>>,
+  ): Promise<CredentialSession | undefined> {
+    const slotKey = ctx.config.args.credentialSlot;
+    if (!slotKey) {
+      return undefined;
+    }
+    try {
+      return await ctx.getCredential<CredentialSession>(slotKey);
+    } catch {
+      // Credential slot configured but not bound — treat as no credential.
+      return undefined;
+    }
   }
 
   private resolveUrl(item: Item, ctx: NodeExecutionContext<HttpRequest<any, any>>): string {
+    // Literal URL in args takes precedence over the legacy urlField approach.
+    const literalUrl = ctx.config.args.url;
+    if (literalUrl && literalUrl.trim().length > 0) {
+      return literalUrl.trim();
+    }
+
     const json = this.asRecord(item.json);
     const candidate = json[ctx.config.urlField];
     if (typeof candidate !== "string" || candidate.trim() === "") {
@@ -85,6 +157,10 @@ export class HttpRequestNode implements RunnableNode<HttpRequest<any, any>> {
     return contentType.split(";")[0]?.trim() || "application/octet-stream";
   }
 
+  private isJsonMimeType(mimeType: string): boolean {
+    return mimeType === "application/json" || mimeType.endsWith("+json");
+  }
+
   private shouldAttachBody(mode: HttpRequestDownloadMode, mimeType: string): boolean {
     if (mode === "always") {
       return true;

package/src/nodes/IsTestRunNode.ts

@@ -0,0 +1,25 @@
+import type { RunnableNode, RunnableNodeExecuteArgs } from "@codemation/core";
+import { emitPorts, node } from "@codemation/core";
+
+import { IsTestRun } from "./isTestRun";
+
+/**
+ * Routes each item to the `true` port if `ctx.testContext` is set (the run was started by the
+ * TestSuiteOrchestrator), else to `false`. Lets workflow authors guard real side-effects:
+ *
+ *   GmailTrigger / TestTrigger → ClassifyAgent → IsTestRun
+ *                                                 ├── true → AssertionNode
+ *                                                 └── false → SendReply
+ */
+@node({ packageName: "@codemation/core-nodes" })
+export class IsTestRunNode implements RunnableNode<IsTestRun<unknown>> {
+  kind = "node" as const;
+
+  execute(args: RunnableNodeExecuteArgs<IsTestRun<unknown>>): unknown {
+    const isTest = args.ctx.testContext !== undefined;
+    return emitPorts({
+      true: isTest ? [args.item] : [],
+      false: isTest ? [] : [args.item],
+    });
+  }
+}

package/src/nodes/NodeBackedToolRuntime.ts

@@ -11,6 +11,8 @@ import type {
   ZodSchemaAny,
 } from "@codemation/core";
 import {
+  AgentConfigInspector,
+  ChildExecutionScopeFactory,
   CoreTokens,
   inject,
   injectable,
@@ -31,6 +33,8 @@ export class NodeBackedToolRuntime {
     private readonly outputNormalizer: NodeOutputNormalizer,
     @inject(RunnableOutputBehaviorResolver)
     private readonly outputBehaviorResolver: RunnableOutputBehaviorResolver,
+    @inject(ChildExecutionScopeFactory)
+    private readonly childExecutionScopeFactory: ChildExecutionScopeFactory,
   ) {}
 
   async execute(
@@ -45,10 +49,7 @@ export class NodeBackedToolRuntime {
       ctx: args.ctx,
       node: config.node,
     });
-    const nodeCtx = {
-      ...args.ctx,
-      config: config.node,
-    } as NodeExecutionContext<RunnableNodeConfig>;
+    const nodeCtx = this.resolveNodeCtx(config, args);
     const resolvedNode = this.nodeResolver.resolve(config.node.type);
     const outputs = await this.executeResolvedNode(resolvedNode, nodeInput, nodeCtx);
     return config.toToolOutput({
@@ -62,6 +63,41 @@ export class NodeBackedToolRuntime {
     });
   }
 
+  /**
+   * Returns a re-rooted child ctx for nested-agent tools (so their LLM/tool connection ids derive
+   * from the tool connection node, telemetry parents under the tool-call span, and connection
+   * invocations carry `parentInvocationId`). Plain runnable tools (non-agent) keep the orchestrator
+   * ctx with only `config` swapped — no nesting concern.
+   *
+   * The caller (`AIAgentNode.createItemScopedTools`) already wraps the orchestrator ctx via
+   * `ConnectionCredentialExecutionContextFactory.forConnectionNode`, so `args.ctx.nodeId` is the
+   * tool's own connection node id (e.g. `AIAgentNode:2__conn__tool__searchInMail`). We pass that
+   * through as the sub-agent's `nodeId`; deriving another `toolConnectionNodeId(args.ctx.nodeId,
+   * config.name)` here would prepend a duplicate `__conn__tool__<name>` segment and exponentially
+   * deepen ids on each invocation, which also breaks credential resolution because user-provided
+   * bindings sit on the single-level connection node id.
+   */
+  private resolveNodeCtx(
+    config: NodeBackedToolConfig<any, ZodSchemaAny, ZodSchemaAny>,
+    args: ToolExecuteArgs,
+  ): NodeExecutionContext<RunnableNodeConfig> {
+    const isNestedAgent = AgentConfigInspector.isAgentNodeConfig(config.node);
+    const hooks = args.hooks;
+    if (!isNestedAgent || !hooks?.parentSpan || !hooks.parentInvocationId) {
+      return {
+        ...args.ctx,
+        config: config.node,
+      } as NodeExecutionContext<RunnableNodeConfig>;
+    }
+    return this.childExecutionScopeFactory.forSubAgent({
+      parentCtx: args.ctx as NodeExecutionContext<RunnableNodeConfig>,
+      childNodeId: args.ctx.nodeId,
+      childConfig: config.node as unknown as RunnableNodeConfig,
+      parentInvocationId: hooks.parentInvocationId,
+      parentSpan: hooks.parentSpan,
+    });
+  }
+
   private async executeResolvedNode(
     resolvedNode: unknown,
     nodeInput: ToolExecuteArgs["item"],

package/src/nodes/TestTriggerNode.ts

@@ -0,0 +1,33 @@
+import type {
+  Items,
+  NodeExecutionContext,
+  NodeOutputs,
+  TestTriggerNodeConfig,
+  TriggerNode,
+  TriggerSetupContext,
+} from "@codemation/core";
+
+import { node } from "@codemation/core";
+
+/**
+ * Author-defined test-fixture trigger. Live activation skips this trigger (filtered by
+ * `triggerKind === "test"` in `TriggerRuntimeService`); the `TestSuiteOrchestrator` drives its
+ * `generateItems` callback during a TestSuiteRun and dispatches one workflow run per yielded item.
+ *
+ * `setup` is intentionally a no-op for symmetry with other trigger nodes — the real work happens
+ * in the orchestrator. `execute` is a passthrough so items provided to `engine.runWorkflow(...)`
+ * (one per case) flow downstream unchanged on `main`.
+ */
+@node({ packageName: "@codemation/core-nodes" })
+export class TestTriggerNode implements TriggerNode<TestTriggerNodeConfig<any>> {
+  kind = "trigger" as const;
+  outputPorts = ["main"] as const;
+
+  async setup(_ctx: TriggerSetupContext<TestTriggerNodeConfig<any>>): Promise<undefined> {
+    return undefined;
+  }
+
+  async execute(items: Items, _ctx: NodeExecutionContext<TestTriggerNodeConfig<any>>): Promise<NodeOutputs> {
+    return { main: items };
+  }
+}

package/src/nodes/aiAgentSupport.types.ts

@@ -1,7 +1,9 @@
 import type {
   AgentToolCall,
+  ConnectionInvocationId,
   Item,
   NodeInputsByPort,
+  TelemetrySpanScope,
   ToolConfig,
   ToolExecuteArgs,
   ZodSchemaAny,
@@ -24,13 +26,24 @@ export type ResolvedTool = Readonly<{
 
 /**
  * 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.
+ * original Zod `inputSchema`.
+ *
+ * `execute` accepts optional `hooks` so the agent coordinator can pass the live `agent.tool.call`
+ * span and the planned tool-call's `invocationId`. Node-backed sub-agent tools use these hooks
+ * via {@link ChildExecutionScopeFactory} to re-root their runtime ctx under the tool-call boundary
+ * (fresh activationId, telemetry parented at the tool-call span, `parentInvocationId` set).
  */
 export type ItemScopedToolBinding = Readonly<{
   config: ToolConfig;
   inputSchema: ZodSchemaAny;
-  execute(input: unknown): Promise<unknown>;
+  execute(input: unknown, hooks?: ItemScopedToolCallHooks): Promise<unknown>;
+}>;
+
+export type ItemScopedToolCallHooks = Readonly<{
+  /** Live agent.tool.call span (used to parent sub-agent telemetry). */
+  parentSpan?: TelemetrySpanScope;
+  /** invocationId of the parent tool call (used to thread `parentInvocationId` through ctx). */
+  parentInvocationId?: ConnectionInvocationId;
 }>;
 
 export type PlannedToolCall = Readonly<{
@@ -38,6 +51,8 @@ export type PlannedToolCall = Readonly<{
   toolCall: AgentToolCall;
   invocationIndex: number;
   nodeId: string;
+  /** Stable id reused across queued / running / completed connection invocation rows for this tool call. */
+  invocationId: string;
 }>;
 
 export type ExecutedToolCall = Readonly<{

package/src/nodes/assertion.ts

@@ -0,0 +1,42 @@
+import type { AssertionResult, Item, NodeExecutionContext, RunnableNodeConfig, TypeToken } from "@codemation/core";
+
+import { AssertionNode } from "./AssertionNode";
+
+export interface AssertionOptions<TInputJson> {
+  readonly name?: string;
+  readonly id?: string;
+  readonly icon?: 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
+   * emit nothing for this case (rare; usually you want at least a "no-op" pass).
+   */
+  assertions(
+    item: Item<TInputJson>,
+    ctx: NodeExecutionContext<Assertion<TInputJson>>,
+  ): Promise<ReadonlyArray<AssertionResult>> | ReadonlyArray<AssertionResult>;
+}
+
+/**
+ * Generic assertion node — the "callback" form. For declarative shorthands (StringEquals,
+ * JudgeByAgent) compose this with helpers added in later phases. Sets `emitsAssertions: true`
+ * so host-side persisters know to record its outputs as `TestAssertion` rows.
+ */
+export class Assertion<TInputJson = unknown> implements RunnableNodeConfig<TInputJson, AssertionResult> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = AssertionNode;
+  readonly icon: string;
+  readonly name: string;
+  readonly id?: string;
+  readonly emitsAssertions = true as const;
+  readonly assertions: AssertionOptions<TInputJson>["assertions"];
+
+  constructor(options: AssertionOptions<TInputJson>) {
+    this.name = options.name ?? "Assertion";
+    this.id = options.id;
+    this.icon = options.icon ?? "lucide:check-circle";
+    this.assertions = options.assertions;
+  }
+}
+
+export { AssertionNode } from "./AssertionNode";

package/src/nodes/collections/collectionDeleteNode.types.ts

@@ -0,0 +1,23 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionDeleteNode = defineNode({
+  key: "collection-delete",
+  title: "Collection: Delete",
+  description: "Delete a row by id from a collection.",
+  icon: "lucide:braces",
+  configSchema: z.object({
+    collectionName: z.string(),
+    id: z.string(),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const result = await store.delete(config.id);
+    return { deleted: result.deleted, id: config.id };
+  },
+});

package/src/nodes/collections/collectionFindOneNode.types.ts

@@ -0,0 +1,26 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionFindOneNode = defineNode({
+  key: "collection-find-one",
+  title: "Collection: Find One",
+  description: "Find a single row matching a filter in a collection.",
+  icon: "lucide:filter",
+  configSchema: z.object({
+    collectionName: z.string(),
+    where: z.record(z.string(), z.unknown()),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const row = await store.findOne(config.where);
+    if (row === null) {
+      return [];
+    }
+    return row;
+  },
+});

package/src/nodes/collections/collectionGetNode.types.ts

@@ -0,0 +1,26 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionGetNode = defineNode({
+  key: "collection-get",
+  title: "Collection: Get",
+  description: "Get a single row by id from a collection.",
+  icon: "lucide:layers",
+  configSchema: z.object({
+    collectionName: z.string(),
+    id: z.string(),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const row = await store.get(config.id);
+    if (row === null) {
+      return [];
+    }
+    return row;
+  },
+});

package/src/nodes/collections/collectionInsertNode.types.ts

@@ -0,0 +1,22 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionInsertNode = defineNode({
+  key: "collection-insert",
+  title: "Collection: Insert",
+  description: "Insert a new row into a collection.",
+  icon: "lucide:boxes",
+  configSchema: z.object({
+    collectionName: z.string(),
+    data: z.record(z.string(), z.unknown()),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    return await store.insert(config.data);
+  },
+});

package/src/nodes/collections/collectionListNode.types.ts

@@ -0,0 +1,30 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionListNode = defineNode({
+  key: "collection-list",
+  title: "Collection: List",
+  description: "List rows from a collection with optional pagination and filtering.",
+  icon: "lucide:split",
+  configSchema: z.object({
+    collectionName: z.string(),
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().nonnegative().optional(),
+    where: z.record(z.string(), z.unknown()).optional(),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    const { rows } = await store.list({
+      limit: config.limit,
+      offset: config.offset,
+      where: config.where,
+    });
+    // Emit one item per row per AGENTS.md engine/node contract.
+    return [...rows];
+  },
+});

package/src/nodes/collections/collectionUpdateNode.types.ts

@@ -0,0 +1,23 @@
+import { defineNode } from "@codemation/core";
+import { z } from "zod";
+
+export const collectionUpdateNode = defineNode({
+  key: "collection-update",
+  title: "Collection: Update",
+  description: "Update a row by id in a collection.",
+  icon: "lucide:square-pen",
+  configSchema: z.object({
+    collectionName: z.string(),
+    id: z.string(),
+    patch: z.record(z.string(), z.unknown()),
+  }),
+  async execute(_args, { config, execution }) {
+    const store = execution.collections?.[config.collectionName];
+    if (!store) {
+      throw new Error(
+        `Collection "${config.collectionName}" is not registered. Add defineCollection to your codemation config.`,
+      );
+    }
+    return await store.update(config.id, config.patch);
+  },
+});

package/src/nodes/collections/index.ts

@@ -0,0 +1,6 @@
+export { collectionInsertNode } from "./collectionInsertNode.types";
+export { collectionGetNode } from "./collectionGetNode.types";
+export { collectionFindOneNode } from "./collectionFindOneNode.types";
+export { collectionListNode } from "./collectionListNode.types";
+export { collectionUpdateNode } from "./collectionUpdateNode.types";
+export { collectionDeleteNode } from "./collectionDeleteNode.types";

package/src/nodes/httpRequest.ts

@@ -1,5 +1,18 @@
-import { RetryPolicy, type RetryPolicySpec, type RunnableNodeConfig, type TypeToken } from "@codemation/core";
+import {
+  RetryPolicy,
+  type CredentialRequirement,
+  type RetryPolicySpec,
+  type RunnableNodeConfig,
+  type TypeToken,
+} from "@codemation/core";
 
+import type { HttpBodySpec } from "../http/httpRequest.types";
+import {
+  apiKeyCredentialType,
+  basicAuthCredentialType,
+  bearerTokenCredentialType,
+  oauth2ClientCredentialsType,
+} from "../credentials/index";
 import { HttpRequestNode } from "./HttpRequestNodeFactory";
 
 export type HttpRequestDownloadMode = "auto" | "always" | "never";
@@ -13,9 +26,22 @@ export type HttpRequestOutputJson = Readonly<{
   statusText: string;
   mimeType: string;
   headers: Readonly<Record<string, string>>;
+  json?: unknown;
+  text?: string;
   bodyBinaryName?: string;
 }>;
 
+/**
+ * The built-in HTTP request credential type IDs accepted by the `HttpRequest` node.
+ * These match the four generic credential types shipped with `@codemation/core-nodes`.
+ */
+export const HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES: ReadonlyArray<string> = [
+  bearerTokenCredentialType.definition.typeId,
+  apiKeyCredentialType.definition.typeId,
+  basicAuthCredentialType.definition.typeId,
+  oauth2ClientCredentialsType.definition.typeId,
+] as const;
+
 export class HttpRequest<
   TInputJson = Readonly<{ url?: string }>,
   TOutputJson = HttpRequestOutputJson,
@@ -28,8 +54,27 @@ export class HttpRequest<
   constructor(
     public readonly name: string,
     public readonly args: Readonly<{
+      /** HTTP method (default: GET). */
       method?: string;
+      /**
+       * Legacy: field name on item.json to read the URL from.
+       * Use `url` for a literal/templated URL instead.
+       */
       urlField?: string;
+      /** Literal or templated URL. When present, takes precedence over `urlField`. */
+      url?: string;
+      /** Extra headers to add to every request. */
+      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`. */
+      body?: HttpBodySpec;
+      /**
+       * Credential slot key. When set, the node resolves a credential via
+       * `ctx.getCredential(credentialSlot)` and applies it to the request.
+       * The slot must be declared in `getCredentialRequirements()`.
+       */
+      credentialSlot?: string;
       binaryName?: string;
       downloadMode?: HttpRequestDownloadMode;
       id?: string;
@@ -56,6 +101,21 @@ export class HttpRequest<
   get downloadMode(): HttpRequestDownloadMode {
     return this.args.downloadMode ?? "auto";
   }
+
+  getCredentialRequirements(): ReadonlyArray<CredentialRequirement> {
+    if (!this.args.credentialSlot) {
+      return [];
+    }
+    return [
+      {
+        slotKey: this.args.credentialSlot,
+        label: "Authentication",
+        acceptedTypes: HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES,
+        optional: true,
+        helpText: "Optional credential for authenticating the HTTP request.",
+      },
+    ];
+  }
 }
 
 export { HttpRequestNode } from "./HttpRequestNodeFactory";

package/src/nodes/isTestRun.ts

@@ -0,0 +1,24 @@
+import type { RunnableNodeConfig, TypeToken } from "@codemation/core";
+
+import { IsTestRunNode } from "./IsTestRunNode";
+
+/**
+ * Branches per-item on whether the current run is a test run. Output ports: `true`, `false`.
+ * The wire payload is unchanged — this is a router, not a transform.
+ */
+export class IsTestRun<TInputJson = unknown> implements RunnableNodeConfig<TInputJson, TInputJson> {
+  readonly kind = "node" as const;
+  readonly type: TypeToken<unknown> = IsTestRunNode;
+  readonly execution = { hint: "local" } as const;
+  readonly icon = "lucide:flask-conical" as const;
+  readonly declaredOutputPorts = ["true", "false"] as const;
+  readonly name: string;
+  readonly id?: string;
+
+  constructor(name: string = "Is test run?", id?: string) {
+    this.name = name;
+    this.id = id;
+  }
+}
+
+export { IsTestRunNode } from "./IsTestRunNode";