@oneuptime/common 11.5.4 → 11.5.5

package/Tests/Types/AI/CodeFixTaskType.test.ts

@@ -0,0 +1,152 @@
+import CodeFixTaskType, {
+  CodeFixContextKind,
+  CodeFixTaskTypeHelper,
+} from "../../../Types/AI/CodeFixTaskType";
+
+describe("CodeFixTaskTypeHelper", () => {
+  describe("getUserTriggerableTaskTypes", () => {
+    test("only exception-page recipes are user triggerable", () => {
+      expect(CodeFixTaskTypeHelper.getUserTriggerableTaskTypes()).toEqual([
+        CodeFixTaskType.FixException,
+        CodeFixTaskType.WriteRegressionTest,
+      ]);
+    });
+  });
+
+  describe("isUserTriggerable", () => {
+    test.each([
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.WriteRegressionTest,
+    ])("returns true for %s", (taskType: CodeFixTaskType) => {
+      expect(CodeFixTaskTypeHelper.isUserTriggerable(taskType)).toBe(true);
+    });
+
+    test.each([
+      CodeFixTaskType.ImproveInstrumentation,
+      CodeFixTaskType.FixPerformance,
+      CodeFixTaskType.FixFromIncident,
+    ])(
+      "returns false for %s (not exception-page triggered)",
+      (taskType: CodeFixTaskType) => {
+        expect(CodeFixTaskTypeHelper.isUserTriggerable(taskType)).toBe(false);
+      },
+    );
+  });
+
+  describe("getContextKind", () => {
+    test.each([
+      [CodeFixTaskType.FixException, CodeFixContextKind.TelemetryException],
+      [
+        CodeFixTaskType.WriteRegressionTest,
+        CodeFixContextKind.TelemetryException,
+      ],
+      [
+        CodeFixTaskType.ImproveInstrumentation,
+        CodeFixContextKind.IncidentOrAlertSubject,
+      ],
+      [
+        CodeFixTaskType.FixFromIncident,
+        CodeFixContextKind.IncidentOrAlertSubject,
+      ],
+      [CodeFixTaskType.FixPerformance, CodeFixContextKind.TaskContext],
+    ])(
+      "maps %s to %s",
+      (taskType: CodeFixTaskType, expected: CodeFixContextKind) => {
+        expect(CodeFixTaskTypeHelper.getContextKind(taskType)).toBe(expected);
+      },
+    );
+
+    test("every task type resolves to a known context kind", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(Object.values(CodeFixContextKind)).toContain(
+          CodeFixTaskTypeHelper.getContextKind(taskType),
+        );
+      }
+    });
+  });
+
+  describe("requiresTelemetryException", () => {
+    test.each([
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.WriteRegressionTest,
+    ])("returns true for %s", (taskType: CodeFixTaskType) => {
+      expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+        true,
+      );
+    });
+
+    test.each([
+      CodeFixTaskType.ImproveInstrumentation,
+      CodeFixTaskType.FixPerformance,
+      CodeFixTaskType.FixFromIncident,
+    ])("returns false for %s", (taskType: CodeFixTaskType) => {
+      expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+        false,
+      );
+    });
+
+    test("stays in sync with getContextKind", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+          CodeFixTaskTypeHelper.getContextKind(taskType) ===
+            CodeFixContextKind.TelemetryException,
+        );
+      }
+    });
+
+    test("every user-triggerable recipe is exception-based", () => {
+      for (const taskType of CodeFixTaskTypeHelper.getUserTriggerableTaskTypes()) {
+        expect(CodeFixTaskTypeHelper.requiresTelemetryException(taskType)).toBe(
+          true,
+        );
+      }
+    });
+  });
+
+  describe("isValidTaskType", () => {
+    test("accepts every enum value", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(CodeFixTaskTypeHelper.isValidTaskType(taskType)).toBe(true);
+      }
+    });
+
+    test.each(["", "NotATaskType", "fixexception"])(
+      "rejects %p",
+      (value: string) => {
+        expect(CodeFixTaskTypeHelper.isValidTaskType(value)).toBe(false);
+      },
+    );
+  });
+
+  describe("fromDatabaseValue", () => {
+    test("normalizes a legacy null/undefined column to FixException", () => {
+      expect(CodeFixTaskTypeHelper.fromDatabaseValue(null)).toBe(
+        CodeFixTaskType.FixException,
+      );
+      expect(CodeFixTaskTypeHelper.fromDatabaseValue(undefined)).toBe(
+        CodeFixTaskType.FixException,
+      );
+    });
+
+    test.each(["", "NotATaskType"])(
+      "falls back to FixException for the unrecognized value %p",
+      (value: string) => {
+        expect(CodeFixTaskTypeHelper.fromDatabaseValue(value)).toBe(
+          CodeFixTaskType.FixException,
+        );
+      },
+    );
+
+    test("round-trips every valid task type", () => {
+      for (const taskType of Object.values(CodeFixTaskType)) {
+        expect(CodeFixTaskTypeHelper.fromDatabaseValue(taskType)).toBe(
+          taskType,
+        );
+        // Also accepts the raw wire string.
+        expect(
+          CodeFixTaskTypeHelper.fromDatabaseValue(taskType.toString()),
+        ).toBe(taskType);
+      }
+    });
+  });
+});

package/Tests/Types/AI/FixPullRequestCiStatus.test.ts

@@ -0,0 +1,181 @@
+import FixPullRequestCiStatus, {
+  FixPullRequestCiStatusHelper,
+} from "../../../Types/AI/FixPullRequestCiStatus";
+import CodeFixTaskType, {
+  CodeFixTaskTypeHelper,
+} from "../../../Types/AI/CodeFixTaskType";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * B4 Tier 1: the CI-conclusion roll-up and the SHOULD-FAIL rule. These pin
+ * the honesty contract: a repo without CI is NoCiConfigured (unverified,
+ * never verified — G9), conclusions are only final once every check
+ * completed, and a RED conclusion on a should-fail regression-test PR is the
+ * desired signal.
+ */
+
+describe("FixPullRequestCiStatusHelper.rollUpConclusion", () => {
+  test("zero check runs means NoCiConfigured — never Green", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 0,
+        completed: 0,
+        failed: 0,
+        pending: 0,
+      }),
+    ).toBe(FixPullRequestCiStatus.NoCiConfigured);
+  });
+
+  test("any pending run means Pending", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 3,
+        completed: 2,
+        failed: 0,
+        pending: 1,
+      }),
+    ).toBe(FixPullRequestCiStatus.Pending);
+  });
+
+  test("pending wins over failed — a conclusion is only final once every check completed", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 3,
+        completed: 1,
+        failed: 1,
+        pending: 2,
+      }),
+    ).toBe(FixPullRequestCiStatus.Pending);
+  });
+
+  test("any failed run (all completed) means Red", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 4,
+        completed: 4,
+        failed: 1,
+        pending: 0,
+      }),
+    ).toBe(FixPullRequestCiStatus.Red);
+  });
+
+  test("all completed and none failed means Green", () => {
+    expect(
+      FixPullRequestCiStatusHelper.rollUpConclusion({
+        total: 4,
+        completed: 4,
+        failed: 0,
+        pending: 0,
+      }),
+    ).toBe(FixPullRequestCiStatus.Green);
+  });
+});
+
+describe("FixPullRequestCiStatusHelper.applyTaskType (the SHOULD-FAIL rule)", () => {
+  test("WriteRegressionTest + Red maps to ExpectedFailureObserved", () => {
+    expect(
+      FixPullRequestCiStatusHelper.applyTaskType({
+        conclusion: FixPullRequestCiStatus.Red,
+        taskType: CodeFixTaskType.WriteRegressionTest,
+      }),
+    ).toBe(FixPullRequestCiStatus.ExpectedFailureObserved);
+  });
+
+  test("fix-type recipes keep Red as Red", () => {
+    for (const taskType of [
+      CodeFixTaskType.FixException,
+      CodeFixTaskType.ImproveInstrumentation,
+      CodeFixTaskType.FixPerformance,
+      CodeFixTaskType.FixFromIncident,
+    ]) {
+      expect(
+        FixPullRequestCiStatusHelper.applyTaskType({
+          conclusion: FixPullRequestCiStatus.Red,
+          taskType,
+        }),
+      ).toBe(FixPullRequestCiStatus.Red);
+    }
+  });
+
+  test("legacy null task type normalizes to FixException, so Red stays Red", () => {
+    expect(
+      FixPullRequestCiStatusHelper.applyTaskType({
+        conclusion: FixPullRequestCiStatus.Red,
+        taskType: CodeFixTaskTypeHelper.fromDatabaseValue(null),
+      }),
+    ).toBe(FixPullRequestCiStatus.Red);
+  });
+
+  test("non-Red conclusions pass through unchanged even for WriteRegressionTest", () => {
+    for (const conclusion of [
+      FixPullRequestCiStatus.Green,
+      FixPullRequestCiStatus.Pending,
+      FixPullRequestCiStatus.NoCiConfigured,
+    ]) {
+      expect(
+        FixPullRequestCiStatusHelper.applyTaskType({
+          conclusion,
+          taskType: CodeFixTaskType.WriteRegressionTest,
+        }),
+      ).toBe(conclusion);
+    }
+  });
+});
+
+describe("FixPullRequestCiStatusHelper.isVerified (the G9 predicate)", () => {
+  test("only Green and ExpectedFailureObserved are verified", () => {
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(FixPullRequestCiStatus.Green),
+    ).toBe(true);
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(
+        FixPullRequestCiStatus.ExpectedFailureObserved,
+      ),
+    ).toBe(true);
+  });
+
+  test("absence of CI is NEVER verified — nor is pending, red, or unpolled null", () => {
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(
+        FixPullRequestCiStatus.NoCiConfigured,
+      ),
+    ).toBe(false);
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(FixPullRequestCiStatus.Pending),
+    ).toBe(false);
+    expect(
+      FixPullRequestCiStatusHelper.isVerified(FixPullRequestCiStatus.Red),
+    ).toBe(false);
+    expect(FixPullRequestCiStatusHelper.isVerified(null)).toBe(false);
+    expect(FixPullRequestCiStatusHelper.isVerified(undefined)).toBe(false);
+  });
+});
+
+describe("FixPullRequestCiStatusHelper.describeForProgressLog", () => {
+  test("green line carries the check counts", () => {
+    expect(
+      FixPullRequestCiStatusHelper.describeForProgressLog({
+        ciStatus: FixPullRequestCiStatus.Green,
+        counts: { total: 4, completed: 4, failed: 0, pending: 0 },
+      }),
+    ).toBe("CI on the fix PR: Green (4/4 checks passed)");
+  });
+
+  test("expected-failure line says the failure is the desired signal", () => {
+    expect(
+      FixPullRequestCiStatusHelper.describeForProgressLog({
+        ciStatus: FixPullRequestCiStatus.ExpectedFailureObserved,
+        counts: { total: 3, completed: 3, failed: 1, pending: 0 },
+      }),
+    ).toContain("expected failure observed");
+  });
+
+  test("no-CI line says the fix is unverified", () => {
+    expect(
+      FixPullRequestCiStatusHelper.describeForProgressLog({
+        ciStatus: FixPullRequestCiStatus.NoCiConfigured,
+        counts: { total: 0, completed: 0, failed: 0, pending: 0 },
+      }),
+    ).toContain("unverified");
+  });
+});

package/Tests/Types/Monitor/MonitorStepSqlMonitor.test.ts

@@ -0,0 +1,110 @@
+import MonitorStepSqlMonitor, {
+  MonitorStepSqlMonitorUtil,
+  clampSqlConnectionTimeoutInMs,
+  clampSqlMaxRows,
+  clampSqlStatementTimeoutInMs,
+  DEFAULT_SQL_CONNECTION_TIMEOUT_IN_MS,
+  DEFAULT_SQL_MAX_ROWS,
+  DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+  MAX_SQL_CONNECTION_TIMEOUT_IN_MS,
+  MAX_SQL_MAX_ROWS,
+  MAX_SQL_STATEMENT_TIMEOUT_IN_MS,
+} from "../../../Types/Monitor/MonitorStepSqlMonitor";
+import SqlDatabaseType from "../../../Types/Monitor/SqlDatabaseType";
+import { JSONObject } from "../../../Types/JSON";
+
+describe("MonitorStepSqlMonitorUtil", () => {
+  describe("getDefault", () => {
+    test("returns a PostgreSQL default with safe caps", () => {
+      const def: MonitorStepSqlMonitor = MonitorStepSqlMonitorUtil.getDefault();
+      expect(def.databaseType).toBe(SqlDatabaseType.PostgreSQL);
+      expect(def.port).toBe(5432);
+      expect(def.useSsl).toBe(false);
+      expect(def.rejectUnauthorizedSsl).toBe(true);
+      expect(def.statementTimeoutInMs).toBe(
+        DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(def.connectionTimeoutInMs).toBe(
+        DEFAULT_SQL_CONNECTION_TIMEOUT_IN_MS,
+      );
+      expect(def.maxRows).toBe(DEFAULT_SQL_MAX_ROWS);
+    });
+  });
+
+  describe("clamps", () => {
+    test("statement timeout is clamped to the max and defaulted when invalid", () => {
+      expect(clampSqlStatementTimeoutInMs(999999)).toBe(
+        MAX_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlStatementTimeoutInMs(0)).toBe(
+        DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlStatementTimeoutInMs(-5)).toBe(
+        DEFAULT_SQL_STATEMENT_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlStatementTimeoutInMs(8000)).toBe(8000);
+    });
+
+    test("connection timeout is clamped to the max", () => {
+      expect(clampSqlConnectionTimeoutInMs(999999)).toBe(
+        MAX_SQL_CONNECTION_TIMEOUT_IN_MS,
+      );
+      expect(clampSqlConnectionTimeoutInMs(5000)).toBe(5000);
+    });
+
+    test("maxRows is clamped, floored, and defaulted", () => {
+      expect(clampSqlMaxRows(999999)).toBe(MAX_SQL_MAX_ROWS);
+      expect(clampSqlMaxRows(0)).toBe(DEFAULT_SQL_MAX_ROWS);
+      expect(clampSqlMaxRows(12.9)).toBe(12);
+    });
+  });
+
+  describe("fromJSON/toJSON round-trip", () => {
+    test("preserves values and clamps out-of-range inputs", () => {
+      const json: JSONObject = {
+        databaseType: SqlDatabaseType.PostgreSQL,
+        host: "db.internal",
+        port: 5433,
+        databaseName: "orders",
+        username: "readonly",
+        password: "{{monitorSecrets.dbPass}}",
+        useSsl: true,
+        rejectUnauthorizedSsl: false,
+        query: "SELECT COUNT(*) FROM orders",
+        connectionTimeoutInMs: 999999,
+        statementTimeoutInMs: 20000,
+        maxRows: 999999,
+      };
+
+      const parsed: MonitorStepSqlMonitor =
+        MonitorStepSqlMonitorUtil.fromJSON(json);
+
+      expect(parsed.host).toBe("db.internal");
+      expect(parsed.port).toBe(5433);
+      expect(parsed.password).toBe("{{monitorSecrets.dbPass}}");
+      expect(parsed.useSsl).toBe(true);
+      expect(parsed.rejectUnauthorizedSsl).toBe(false);
+      // clamped
+      expect(parsed.connectionTimeoutInMs).toBe(
+        MAX_SQL_CONNECTION_TIMEOUT_IN_MS,
+      );
+      expect(parsed.maxRows).toBe(MAX_SQL_MAX_ROWS);
+
+      const roundTripped: MonitorStepSqlMonitor =
+        MonitorStepSqlMonitorUtil.fromJSON(
+          MonitorStepSqlMonitorUtil.toJSON(parsed),
+        );
+      expect(roundTripped).toEqual(parsed);
+    });
+
+    test("defaults rejectUnauthorizedSsl to true when absent", () => {
+      const parsed: MonitorStepSqlMonitor = MonitorStepSqlMonitorUtil.fromJSON({
+        host: "h",
+        databaseName: "d",
+        query: "SELECT 1",
+      });
+      expect(parsed.rejectUnauthorizedSsl).toBe(true);
+      expect(parsed.useSsl).toBe(false);
+    });
+  });
+});

package/Tests/Types/Monitor/SqlDatabaseType.test.ts

@@ -0,0 +1,55 @@
+import SqlDatabaseType, {
+  SqlDatabaseTypeUtil,
+} from "../../../Types/Monitor/SqlDatabaseType";
+
+describe("SqlDatabaseTypeUtil", () => {
+  describe("getSupportedDatabaseTypes", () => {
+    test("supports PostgreSQL, MySQL, and Microsoft SQL Server", () => {
+      const supported: Array<SqlDatabaseType> =
+        SqlDatabaseTypeUtil.getSupportedDatabaseTypes();
+
+      expect(supported).toContain(SqlDatabaseType.PostgreSQL);
+      expect(supported).toContain(SqlDatabaseType.MySQL);
+      expect(supported).toContain(SqlDatabaseType.MicrosoftSqlServer);
+      expect(supported).toHaveLength(3);
+    });
+  });
+
+  describe("isSupported", () => {
+    test("returns true for every enum member (all engines ship an executor)", () => {
+      expect(SqlDatabaseTypeUtil.isSupported(SqlDatabaseType.PostgreSQL)).toBe(
+        true,
+      );
+      expect(SqlDatabaseTypeUtil.isSupported(SqlDatabaseType.MySQL)).toBe(true);
+      expect(
+        SqlDatabaseTypeUtil.isSupported(SqlDatabaseType.MicrosoftSqlServer),
+      ).toBe(true);
+    });
+
+    test("returns false for an engine that is not in the enum", () => {
+      expect(
+        SqlDatabaseTypeUtil.isSupported("OracleDatabase" as SqlDatabaseType),
+      ).toBe(false);
+    });
+  });
+
+  describe("getDefaultPort", () => {
+    test("returns the well-known default port per engine", () => {
+      expect(
+        SqlDatabaseTypeUtil.getDefaultPort(SqlDatabaseType.PostgreSQL),
+      ).toBe(5432);
+      expect(SqlDatabaseTypeUtil.getDefaultPort(SqlDatabaseType.MySQL)).toBe(
+        3306,
+      );
+      expect(
+        SqlDatabaseTypeUtil.getDefaultPort(SqlDatabaseType.MicrosoftSqlServer),
+      ).toBe(1433);
+    });
+
+    test("falls back to the PostgreSQL port for an unknown engine", () => {
+      expect(
+        SqlDatabaseTypeUtil.getDefaultPort("OracleDatabase" as SqlDatabaseType),
+      ).toBe(5432);
+    });
+  });
+});

package/Tests/Types/Workflow/AIGenerateTextMetadata.test.ts

@@ -0,0 +1,180 @@
+import Components, { Categories } from "../../../Types/Workflow/Components";
+import AIComponents from "../../../Types/Workflow/Components/AI";
+import ComponentID from "../../../Types/Workflow/ComponentID";
+import ComponentMetadata, {
+  Argument,
+  ComponentCategory,
+  ComponentInputType,
+  ComponentType,
+  Port,
+  ReturnValue,
+} from "../../../Types/Workflow/Component";
+import { describe, expect, test } from "@jest/globals";
+
+function byId<T extends { id: string }>(items: Array<T>, id: string): T {
+  const item: T | undefined = items.find((candidate: T) => {
+    return candidate.id === id;
+  });
+
+  if (!item) {
+    throw new Error(`Expected item with id ${id}`);
+  }
+
+  return item;
+}
+
+describe("Generate Text with AI workflow metadata", () => {
+  const metadata: ComponentMetadata = byId(
+    AIComponents,
+    ComponentID.AIGenerateText,
+  );
+
+  test("uses the stable persisted component id", () => {
+    expect(ComponentID.AIGenerateText).toBe("ai-generate-text");
+    expect(metadata.id).toBe("ai-generate-text");
+  });
+
+  test("is a discoverable AI component", () => {
+    expect(metadata.title).toBe("Generate Text with AI");
+    expect(metadata.category).toBe("AI");
+    expect(metadata.componentType).toBe(ComponentType.Component);
+    expect(metadata.description).toMatch(/AI|LLM/i);
+    expect(metadata.iconProp).toBeDefined();
+
+    expect(
+      Components.filter((component: ComponentMetadata) => {
+        return component.id === ComponentID.AIGenerateText;
+      }),
+    ).toHaveLength(1);
+    expect(
+      Categories.some((category: ComponentCategory) => {
+        return category.name === "AI";
+      }),
+    ).toBe(true);
+  });
+
+  test("publishes the complete, stable argument contract", () => {
+    expect(
+      metadata.arguments.map((argument: Argument) => {
+        return argument.id;
+      }),
+    ).toEqual([
+      "system-prompt",
+      "prompt",
+      "context",
+      "temperature",
+      "max-output-tokens",
+    ]);
+
+    expect(byId(metadata.arguments, "prompt")).toMatchObject({
+      required: true,
+      type: ComponentInputType.Markdown,
+    });
+    expect(byId(metadata.arguments, "system-prompt")).toMatchObject({
+      required: false,
+      type: ComponentInputType.LongText,
+    });
+    expect(byId(metadata.arguments, "context")).toMatchObject({
+      required: false,
+      type: ComponentInputType.JSON,
+    });
+    expect(byId(metadata.arguments, "temperature")).toMatchObject({
+      required: false,
+      type: ComponentInputType.Decimal,
+    });
+    expect(byId(metadata.arguments, "max-output-tokens")).toMatchObject({
+      required: false,
+      type: ComponentInputType.Number,
+    });
+  });
+
+  test("does not expose provider credentials or arbitrary endpoints as inputs", () => {
+    const argumentIds: Array<string> = metadata.arguments.map(
+      (argument: Argument) => {
+        return argument.id.toLowerCase();
+      },
+    );
+
+    expect(argumentIds).not.toContain("api-key");
+    expect(argumentIds).not.toContain("provider");
+    expect(argumentIds).not.toContain("provider-id");
+    expect(argumentIds).not.toContain("model");
+    expect(argumentIds).not.toContain("base-url");
+  });
+
+  test("marks prompt-bearing inputs as sensitive workflow-log data", () => {
+    for (const id of ["prompt", "system-prompt", "context"]) {
+      expect(byId(metadata.arguments, id).isSensitive).toBe(true);
+    }
+
+    expect(byId(metadata.arguments, "temperature").isSensitive).not.toBe(true);
+    expect(byId(metadata.arguments, "max-output-tokens").isSensitive).not.toBe(
+      true,
+    );
+  });
+
+  test("publishes typed usage and diagnostic return values", () => {
+    expect(
+      metadata.returnValues.map((returnValue: ReturnValue) => {
+        return returnValue.id;
+      }),
+    ).toEqual([
+      "response",
+      "provider",
+      "model",
+      "total-tokens",
+      "completion-tokens",
+      "llm-log-id",
+      "error",
+    ]);
+
+    expect(byId(metadata.returnValues, "response").type).toBe(
+      ComponentInputType.LongText,
+    );
+    expect(byId(metadata.returnValues, "provider").type).toBe(
+      ComponentInputType.Text,
+    );
+    expect(byId(metadata.returnValues, "model").type).toBe(
+      ComponentInputType.Text,
+    );
+    expect(byId(metadata.returnValues, "total-tokens").type).toBe(
+      ComponentInputType.Number,
+    );
+    expect(byId(metadata.returnValues, "completion-tokens").type).toBe(
+      ComponentInputType.Number,
+    );
+    expect(byId(metadata.returnValues, "llm-log-id").type).toBe(
+      ComponentInputType.Text,
+    );
+    expect(byId(metadata.returnValues, "error").type).toBe(
+      ComponentInputType.Text,
+    );
+  });
+
+  test("redacts model-generated content while leaving usage metadata loggable", () => {
+    expect(byId(metadata.returnValues, "response").isSensitive).toBe(true);
+
+    for (const id of [
+      "provider",
+      "model",
+      "total-tokens",
+      "completion-tokens",
+      "llm-log-id",
+    ]) {
+      expect(byId(metadata.returnValues, id).isSensitive).not.toBe(true);
+    }
+  });
+
+  test("has one input port and explicit success and error branches", () => {
+    expect(
+      metadata.inPorts.map((port: Port) => {
+        return port.id;
+      }),
+    ).toEqual(["in"]);
+    expect(
+      metadata.outPorts.map((port: Port) => {
+        return port.id;
+      }),
+    ).toEqual(["success", "error"]);
+  });
+});