@nyxa/automation 0.1.0

package/dist/codex-output.js

@@ -0,0 +1,167 @@
+import { AutomationError } from "./errors.js";
+export function prepareCodexOutput(schema) {
+    const lowered = lowerSchema(schema);
+    if (schema.type === "object") {
+        return lowered;
+    }
+    return {
+        schema: {
+            type: "object",
+            properties: { value: lowered.schema },
+            required: ["value"],
+            additionalProperties: false,
+        },
+        normalize(value) {
+            return isExactWrapper(value, "value")
+                ? lowered.normalize(value.value)
+                : value;
+        },
+    };
+}
+function lowerSchema(schema, path = []) {
+    if (schema.type === "object") {
+        return lowerObjectSchema(schema, path);
+    }
+    if (Array.isArray(schema.anyOf)) {
+        return isNullableSchema(schema.anyOf)
+            ? lowerNullableSchema(schema, path)
+            : lowerUnionSchema(schema, path);
+    }
+    if (schema.type === "array") {
+        const item = lowerSchema(asJsonSchema(schema.items), [...path, "*"]);
+        return {
+            schema: { ...schema, items: item.schema },
+            normalize(value) {
+                return Array.isArray(value)
+                    ? value.map((entry) => item.normalize(entry))
+                    : value;
+            },
+        };
+    }
+    return { schema, normalize: (value) => value };
+}
+function lowerNullableSchema(schema, path) {
+    const alternatives = schema.anyOf;
+    const value = lowerSchema(asJsonSchema(alternatives[0]), path);
+    const nullSchema = asJsonSchema(alternatives[1]);
+    return {
+        schema: { ...schema, anyOf: [value.schema, nullSchema] },
+        normalize(nativeValue) {
+            return nativeValue === null ? null : value.normalize(nativeValue);
+        },
+    };
+}
+function lowerUnionSchema(schema, path) {
+    const { anyOf, ...annotations } = schema;
+    const alternatives = anyOf.map((candidate) => lowerSchema(asJsonSchema(candidate), path));
+    return {
+        schema: {
+            ...annotations,
+            anyOf: alternatives.map((alternative, index) => {
+                const key = variantKey(index);
+                return {
+                    type: "object",
+                    properties: { [key]: alternative.schema },
+                    required: [key],
+                    additionalProperties: false,
+                };
+            }),
+        },
+        normalize(value) {
+            if (!isRecord(value) || Object.keys(value).length !== 1) {
+                return value;
+            }
+            for (const [index, alternative] of alternatives.entries()) {
+                const key = variantKey(index);
+                if (Object.hasOwn(value, key)) {
+                    return alternative.normalize(value[key]);
+                }
+            }
+            return value;
+        },
+    };
+}
+function lowerObjectSchema(schema, path) {
+    const properties = asSchemaProperties(schema.properties);
+    const portableRequired = new Set(asStringArray(schema.required));
+    const loweredEntries = Object.entries(properties).map(([key, property]) => {
+        const optional = !portableRequired.has(key);
+        if (optional && acceptsNull(property)) {
+            const propertyPath = [...path, key].join(".");
+            throw new AutomationError("OUTPUT_SCHEMA_UNSUPPORTED", `Codex cannot distinguish an absent optional property from null at ${propertyPath}.`);
+        }
+        const lowered = lowerSchema(property, [...path, key]);
+        const transported = optional
+            ? makeNullable(lowered.schema)
+            : lowered.schema;
+        return { key, lowered, optional, transported };
+    });
+    const loweredProperties = Object.fromEntries(loweredEntries.map((entry) => [entry.key, entry.transported]));
+    return {
+        schema: {
+            ...schema,
+            properties: loweredProperties,
+            required: Object.keys(properties),
+        },
+        normalize(value) {
+            if (!isRecord(value)) {
+                return value;
+            }
+            const normalized = { ...value };
+            for (const entry of loweredEntries) {
+                if (entry.optional && normalized[entry.key] === null) {
+                    delete normalized[entry.key];
+                }
+                else if (Object.hasOwn(normalized, entry.key)) {
+                    normalized[entry.key] = entry.lowered.normalize(normalized[entry.key]);
+                }
+            }
+            return normalized;
+        },
+    };
+}
+function makeNullable(schema) {
+    const { description, ...undocumentedSchema } = schema;
+    return {
+        anyOf: [undocumentedSchema, { type: "null" }],
+        ...(description === undefined ? {} : { description }),
+    };
+}
+function acceptsNull(schema) {
+    return (schema.type === "null" ||
+        schema.const === null ||
+        (Array.isArray(schema.enum) && schema.enum.includes(null)) ||
+        (Array.isArray(schema.anyOf) &&
+            schema.anyOf.some((candidate) => acceptsNull(asJsonSchema(candidate)))));
+}
+function isNullableSchema(anyOf) {
+    return anyOf.length === 2 && asJsonSchema(anyOf[1]).type === "null";
+}
+function variantKey(index) {
+    return `variant_${String(index)}`;
+}
+function isExactWrapper(value, key) {
+    return (isRecord(value) &&
+        Object.keys(value).length === 1 &&
+        Object.hasOwn(value, key));
+}
+function asJsonSchema(value) {
+    return isRecord(value) ? value : {};
+}
+function asSchemaProperties(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, property]) => [
+        key,
+        asJsonSchema(property),
+    ]));
+}
+function asStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/codex.d.ts

@@ -0,0 +1,17 @@
+import { type Harness } from "./harness.js";
+import type { NoExtraKeys } from "./type-utils.js";
+export declare const CODEX_HARNESS_PREFLIGHT: {
+    readonly harnessName: "Codex";
+    readonly minimumVersion: readonly [0, 144, 0];
+    readonly unsupportedVersionMessage: "Codex CLI 0.144.0 or later is required.";
+    readonly versionPattern: RegExp;
+};
+export type CodexEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export interface CodexOptions {
+    readonly executable?: string;
+    readonly model?: string;
+    readonly effort?: CodexEffort;
+    readonly profile?: string;
+}
+export declare function codex(): Harness;
+export declare function codex<const TOptions extends CodexOptions>(options: TOptions & NoExtraKeys<TOptions, CodexOptions>): Harness;

package/dist/codex.js

@@ -0,0 +1,228 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { prepareCodexOutput } from "./codex-output.js";
+import { AutomationError } from "./errors.js";
+import { createHarnessPreflight, harnessProcessExitError, harnessProcessFailureCause, runHarnessProcess, } from "./harness-process.js";
+import { createHarness, harnessProcessControls, } from "./harness.js";
+export const CODEX_HARNESS_PREFLIGHT = {
+    harnessName: "Codex",
+    minimumVersion: [0, 144, 0],
+    unsupportedVersionMessage: "Codex CLI 0.144.0 or later is required.",
+    versionPattern: /\bcodex(?:-cli)?\s+(\d+)\.(\d+)\.(\d+)(?:-([0-9a-z.-]+))?(?:\+[0-9a-z.-]+)?(?:\s|$)/iu,
+};
+const preflightCodex = createHarnessPreflight(CODEX_HARNESS_PREFLIGHT);
+export function codex(options = {}) {
+    const configuredOptions = Object.freeze({ ...options });
+    return createHarness({
+        name: "Codex",
+        async run(request) {
+            if (request.approval === "auto") {
+                throw new AutomationError("HARNESS_CAPABILITY_UNSUPPORTED", "Codex does not provide non-interactive automatic approvals.");
+            }
+            const preparedOutput = request.output === undefined
+                ? undefined
+                : prepareCodexOutput(request.output.toJSONSchema());
+            const executable = await preflightCodex(configuredOptions.executable ?? "codex", request.environment, harnessProcessControls(request));
+            return executeCodex(executable, configuredOptions, request, preparedOutput);
+        },
+    });
+}
+async function executeCodex(executable, options, request, preparedOutput) {
+    if (preparedOutput !== undefined) {
+        return withOutputSchema(preparedOutput, request.sessionReady, (schemaPath) => executeCodexProcess(executable, options, request, schemaPath));
+    }
+    return executeCodexProcess(executable, options, request);
+}
+async function executeCodexProcess(executable, options, request, outputSchemaPath) {
+    const arguments_ = request.nativeSessionId === undefined
+        ? [
+            "exec",
+            "--json",
+            "--sandbox",
+            codexSandbox(request.access),
+            "-c",
+            'approval_policy="never"',
+        ]
+        : [
+            "exec",
+            "resume",
+            "--json",
+            "-c",
+            `sandbox_mode=${JSON.stringify(codexSandbox(request.access))}`,
+            "-c",
+            'approval_policy="never"',
+        ];
+    if (options.model !== undefined) {
+        arguments_.push("--model", options.model);
+    }
+    if (options.effort !== undefined) {
+        arguments_.push("-c", `model_reasoning_effort=${JSON.stringify(options.effort)}`);
+    }
+    if (options.profile !== undefined && request.nativeSessionId === undefined) {
+        arguments_.push("--profile", options.profile);
+    }
+    if (outputSchemaPath !== undefined) {
+        arguments_.push("--output-schema", outputSchemaPath);
+    }
+    if (request.nativeSessionId !== undefined) {
+        arguments_.push(request.nativeSessionId);
+    }
+    arguments_.push(request.prompt);
+    await request.start();
+    let finalMessage;
+    let nativeSessionId = request.nativeSessionId;
+    let turnCompleted = false;
+    const result = await runHarnessProcess(executable, arguments_, request.workingDirectory, "Codex", {
+        environment: request.environment,
+        ...harnessProcessControls(request),
+        async onStdoutLine(line) {
+            if (line.trim().length === 0) {
+                return;
+            }
+            const event = parseCodexEvent(line);
+            await request.emitNativeEvent(event);
+            if (turnCompleted) {
+                throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex emitted an event after the terminal turn event.");
+            }
+            const eventSessionId = codexSessionId(event);
+            if (eventSessionId !== undefined) {
+                if (nativeSessionId !== undefined &&
+                    eventSessionId !== nativeSessionId) {
+                    throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex resumed a different Session than requested.");
+                }
+                nativeSessionId = eventSessionId;
+            }
+            if (isAgentMessage(event)) {
+                finalMessage = event.item.text;
+            }
+            if (isTurnCompleted(event)) {
+                turnCompleted = true;
+            }
+        },
+    });
+    if (result.exitCode !== 0) {
+        throw harnessProcessExitError("Codex", result);
+    }
+    if (nativeSessionId === undefined) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex completed without a Session identifier.");
+    }
+    if (!turnCompleted) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex completed without a terminal turn event.");
+    }
+    if (finalMessage === undefined) {
+        if (outputSchemaPath !== undefined) {
+            request.sessionReady?.(nativeSessionId);
+            throw new AutomationError("RUN_OUTPUT_INVALID", "The Codex Run completed without structured output.", { cause: new TypeError("Missing final Codex agent message.") });
+        }
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex completed without a final agent message.");
+    }
+    if (outputSchemaPath === undefined) {
+        return { nativeSessionId, value: finalMessage };
+    }
+    try {
+        return {
+            nativeSessionId,
+            value: JSON.parse(finalMessage),
+        };
+    }
+    catch (cause) {
+        request.sessionReady?.(nativeSessionId);
+        throw new AutomationError("RUN_OUTPUT_INVALID", "The Codex Run returned malformed structured output.", { cause });
+    }
+}
+function codexSandbox(access) {
+    switch (access) {
+        case "read":
+            return "read-only";
+        case "write-workspace":
+            return "workspace-write";
+        case "full":
+            return "danger-full-access";
+    }
+}
+async function withOutputSchema(preparedOutput, sessionReady, execute) {
+    let directory;
+    try {
+        directory = await mkdtemp(path.join(os.tmpdir(), "automation-codex-"));
+    }
+    catch (cause) {
+        throw new AutomationError("HARNESS_PROCESS_FAILED", "Could not prepare the Codex structured output schema.", { cause });
+    }
+    const schemaPath = path.join(directory, "output-schema.json");
+    let failure;
+    let nativeValue;
+    try {
+        try {
+            await writeFile(schemaPath, `${JSON.stringify(preparedOutput.schema)}\n`, "utf8");
+        }
+        catch (cause) {
+            throw new AutomationError("HARNESS_PROCESS_FAILED", "Could not prepare the Codex structured output schema.", { cause });
+        }
+        nativeValue = await execute(schemaPath);
+    }
+    catch (cause) {
+        failure = cause;
+    }
+    try {
+        await rm(directory, { force: true, recursive: true });
+    }
+    catch (cleanupCause) {
+        if (failure === undefined) {
+            failure = new AutomationError("HARNESS_PROCESS_FAILED", "Could not clean up the Codex structured output schema.", { cause: cleanupCause });
+        }
+    }
+    if (failure !== undefined) {
+        if (nativeValue !== undefined) {
+            sessionReady?.(nativeValue.nativeSessionId);
+        }
+        throw failure;
+    }
+    if (nativeValue === undefined) {
+        throw new AutomationError("HARNESS_PROCESS_FAILED", "Codex completed without returning a Run result.");
+    }
+    try {
+        return {
+            nativeSessionId: nativeValue.nativeSessionId,
+            value: preparedOutput.normalize(nativeValue.value),
+        };
+    }
+    catch (cause) {
+        sessionReady?.(nativeValue.nativeSessionId);
+        throw cause;
+    }
+}
+function parseCodexEvent(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (cause) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex emitted malformed JSONL.", { cause });
+    }
+}
+function codexSessionId(event) {
+    if (typeof event !== "object" ||
+        event === null ||
+        event.type !== "thread.started") {
+        return undefined;
+    }
+    const threadId = event.thread_id;
+    if (typeof threadId !== "string" || threadId.length === 0) {
+        throw new AutomationError("HARNESS_PROTOCOL_ERROR", "Codex emitted an invalid Session identifier.");
+    }
+    return threadId;
+}
+function isTurnCompleted(event) {
+    return (typeof event === "object" &&
+        event !== null &&
+        event.type === "turn.completed");
+}
+function isAgentMessage(event) {
+    if (typeof event !== "object" || event === null) {
+        return false;
+    }
+    const candidate = event;
+    return (candidate.type === "item.completed" &&
+        candidate.item?.type === "agent_message" &&
+        typeof candidate.item.text === "string");
+}

package/dist/doctor.d.ts

@@ -0,0 +1,17 @@
+export type DoctorHarness = "claude-code" | "codex" | "kimi-code" | "opencode";
+export interface DoctorOptions {
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly harness?: DoctorHarness;
+    readonly invocationDirectory?: string;
+    readonly localPackage?: DoctorLocalPackage;
+    readonly nodeVersion?: string;
+}
+export interface DoctorLocalPackage {
+    readonly binaryAvailable: boolean;
+    readonly version: string;
+}
+export interface DoctorResult {
+    readonly output: string;
+    readonly ready: boolean;
+}
+export declare function diagnoseEnvironment(options?: DoctorOptions): Promise<DoctorResult>;

package/dist/doctor.js

@@ -0,0 +1,138 @@
+import { CLAUDE_CODE_HARNESS_PREFLIGHT } from "./claude-code.js";
+import { CODEX_HARNESS_PREFLIGHT } from "./codex.js";
+import { isAutomationError } from "./errors.js";
+import { inspectHarnessExecutable, runHarnessProcess, } from "./harness-process.js";
+import { KIMI_CODE_HARNESS_PREFLIGHT, verifyKimiCodeAuthentication, } from "./kimi-code.js";
+import { OPENCODE_HARNESS_PREFLIGHT } from "./opencode.js";
+export async function diagnoseEnvironment(options = {}) {
+    const environment = options.environment ?? process.env;
+    const invocationDirectory = options.invocationDirectory ?? process.cwd();
+    const nodeVersion = options.nodeVersion ?? process.versions.node;
+    const nodeReady = nodeMajorVersion(nodeVersion) >= 22;
+    const localPackageReady = options.localPackage?.binaryAvailable === true;
+    const harnesses = options.harness === undefined
+        ? HARNESS_DEFINITIONS
+        : HARNESS_DEFINITIONS.filter((definition) => definition.id === options.harness);
+    const harnessDiagnoses = await Promise.all(harnesses.map(async (definition) => ({
+        definition,
+        diagnosis: await diagnoseHarness(definition, environment, invocationDirectory),
+    })));
+    const anyHarnessReady = harnessDiagnoses.some(({ diagnosis }) => diagnosis.ready);
+    const diagnostics = [
+        diagnostic(nodeReady, `Node.js ${nodeVersion} ${nodeReady ? "meets" : "does not meet"} the requirement: doctor requires 22 or later.`),
+        diagnostic(localPackageReady, options.localPackage === undefined
+            ? "Project-local @nyxa/automation is not installed."
+            : localPackageReady
+                ? `Project-local @nyxa/automation ${options.localPackage.version} is installed.`
+                : `Project-local @nyxa/automation ${options.localPackage.version} is installed, but its automation binary is missing.`),
+        ...harnessDiagnoses.map(({ diagnosis }) => harnessDiagnostic(diagnosis, anyHarnessReady)),
+    ];
+    return {
+        output: `${diagnostics.join("\n")}\n`,
+        ready: nodeReady && localPackageReady && anyHarnessReady,
+    };
+}
+function nodeMajorVersion(version) {
+    const [major] = version.split(".", 1);
+    return Number(major);
+}
+const HARNESS_DEFINITIONS = [
+    {
+        authenticationArguments: ["login", "status"],
+        executable: "codex",
+        id: "codex",
+        preflight: CODEX_HARNESS_PREFLIGHT,
+    },
+    {
+        authenticationArguments: ["auth", "status"],
+        executable: "claude",
+        id: "claude-code",
+        preflight: CLAUDE_CODE_HARNESS_PREFLIGHT,
+    },
+    {
+        executable: "kimi",
+        id: "kimi-code",
+        preflight: KIMI_CODE_HARNESS_PREFLIGHT,
+    },
+    {
+        authenticationArguments: ["auth", "list"],
+        executable: "opencode",
+        id: "opencode",
+        preflight: OPENCODE_HARNESS_PREFLIGHT,
+    },
+];
+async function diagnoseHarness(definition, environment, invocationDirectory) {
+    try {
+        const inspection = await inspectHarnessExecutable(definition.executable, definition.preflight, environment);
+        if (definition.id === "kimi-code") {
+            await verifyKimiCodeAuthentication(inspection.executable, invocationDirectory, environment);
+            return {
+                message: `${definition.preflight.harnessName} ${inspection.version} is installed and authenticated.`,
+                ready: true,
+            };
+        }
+        const authentication = await runHarnessProcess(inspection.executable, definition.authenticationArguments ?? [], invocationDirectory, definition.preflight.harnessName, { environment });
+        if (definition.id === "opencode") {
+            if (authentication.exitCode === 0 &&
+                hasOpenCodeAuthentication(authentication.stdout)) {
+                return {
+                    message: `${definition.preflight.harnessName} ${inspection.version} is installed and authenticated.`,
+                    ready: true,
+                };
+            }
+            return {
+                message: `${definition.preflight.harnessName} ${inspection.version} is installed, but authentication could not be verified.`,
+                ready: false,
+            };
+        }
+        if (authentication.exitCode === 0) {
+            return {
+                message: `${definition.preflight.harnessName} ${inspection.version} is installed and authenticated.`,
+                ready: true,
+            };
+        }
+        if (authentication.exitCode === 1) {
+            return {
+                message: `${definition.preflight.harnessName} ${inspection.version} is installed but not authenticated.`,
+                ready: false,
+            };
+        }
+        return {
+            message: `${definition.preflight.harnessName} ${inspection.version} is installed, but authentication could not be verified.`,
+            ready: false,
+        };
+    }
+    catch (error) {
+        if (isAutomationError(error) && error.code === "HARNESS_NOT_FOUND") {
+            return {
+                message: `${definition.preflight.harnessName} executable was not found.`,
+                ready: false,
+            };
+        }
+        if (isAutomationError(error) &&
+            error.code === "HARNESS_VERSION_UNSUPPORTED") {
+            return {
+                message: error.message,
+                ready: false,
+            };
+        }
+        if (isAutomationError(error)) {
+            return { message: error.message, ready: false };
+        }
+        return {
+            message: `${definition.preflight.harnessName} could not be inspected safely.`,
+            ready: false,
+        };
+    }
+}
+function hasOpenCodeAuthentication(output) {
+    const plainOutput = output.replace(/\u001B\[[0-?]*[ -/]*[@-~]/gu, "");
+    const authenticationCounts = plainOutput.matchAll(/\b(\d+)\s+(?:credentials?|environment variables?)\b/giu);
+    return [...authenticationCounts].some((match) => Number(match[1]) > 0);
+}
+function harnessDiagnostic(diagnosis, anyHarnessReady) {
+    return `[${diagnosis.ready ? "ok" : anyHarnessReady ? "warn" : "fail"}] ${diagnosis.message}`;
+}
+function diagnostic(success, message) {
+    return `[${success ? "ok" : "fail"}] ${message}`;
+}

package/dist/errors.d.ts

@@ -0,0 +1,30 @@
+export type AutomationErrorCode = "EVENT_OBSERVER_FAILED" | "HARNESS_NOT_FOUND" | "HARNESS_CAPABILITY_UNSUPPORTED" | "HARNESS_NOT_AUTHENTICATED" | "HARNESS_PROCESS_FAILED" | "HARNESS_PROTOCOL_ERROR" | "HARNESS_REQUIRED" | "HARNESS_VERSION_UNSUPPORTED" | "OUTPUT_SCHEMA_UNSUPPORTED" | "RUN_CANCELLED" | "RUN_CWD_INVALID" | "RUN_JOURNAL_UNAVAILABLE" | "RUN_OUTPUT_INVALID" | "RUN_POLICY_INVALID" | "RUN_TIMED_OUT" | "SESSION_BUSY" | "SESSION_UNAVAILABLE" | "WORKFLOW_MODULE_LOAD_FAILED" | "WORKFLOW_INPUT_INVALID" | "WORKFLOW_INPUT_UNEXPECTED" | "WORKFLOW_EXECUTION_FAILED" | "WORKFLOW_OUTPUT_INVALID" | "WORKSPACE_CONCURRENCY_CONFLICT";
+export interface AutomationErrorDetails {
+    readonly code: AutomationErrorCode;
+    readonly harness: string | undefined;
+    readonly message: string;
+    readonly runId: string | undefined;
+    readonly sessionId: string | undefined;
+    readonly workflowId: string | undefined;
+}
+export interface AutomationErrorOptions extends ErrorOptions {
+    readonly harness?: string | undefined;
+    readonly runId?: string | undefined;
+    readonly sessionId?: string | undefined;
+    readonly workflowId?: string | undefined;
+}
+declare const automationErrorBrand: unique symbol;
+export declare class AutomationError extends Error {
+    readonly [automationErrorBrand] = true;
+    readonly code: AutomationErrorCode;
+    readonly harness: string | undefined;
+    readonly runId: string | undefined;
+    readonly sessionId: string | undefined;
+    readonly workflowId: string | undefined;
+    constructor(code: AutomationErrorCode, message: string, options?: AutomationErrorOptions);
+    toJSON(): AutomationErrorDetails;
+}
+export declare function isAutomationError(value: unknown): value is AutomationError;
+export declare function automationErrorDetails(error: AutomationError): AutomationErrorDetails;
+export declare function contextualizeAutomationError(cause: unknown, fallbackCode: AutomationErrorCode, fallbackMessage: string, context: AutomationErrorOptions): AutomationError;
+export {};

package/dist/errors.js

@@ -0,0 +1,51 @@
+const automationErrorBrand = Symbol.for("@nyxa/automation/error");
+export class AutomationError extends Error {
+    [automationErrorBrand] = true;
+    code;
+    harness;
+    runId;
+    sessionId;
+    workflowId;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "AutomationError";
+        this.code = code;
+        this.harness = options?.harness;
+        this.runId = options?.runId;
+        this.sessionId = options?.sessionId;
+        this.workflowId = options?.workflowId;
+    }
+    toJSON() {
+        return automationErrorDetails(this);
+    }
+}
+export function isAutomationError(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value[automationErrorBrand] === true);
+}
+export function automationErrorDetails(error) {
+    return {
+        code: error.code,
+        harness: error.harness,
+        message: error.message,
+        runId: error.runId,
+        sessionId: error.sessionId,
+        workflowId: error.workflowId,
+    };
+}
+export function contextualizeAutomationError(cause, fallbackCode, fallbackMessage, context) {
+    if (!isAutomationError(cause)) {
+        return new AutomationError(fallbackCode, fallbackMessage, {
+            ...context,
+            cause,
+        });
+    }
+    return new AutomationError(cause.code, cause.message, {
+        cause: cause.cause,
+        harness: cause.harness ?? context.harness,
+        runId: cause.runId ?? context.runId,
+        sessionId: cause.sessionId ?? context.sessionId,
+        workflowId: cause.workflowId ?? context.workflowId,
+    });
+}