ResponseInput,

ResponseStreamEvent,

} from "openai/resources/responses/responses.js";

import { toErrorObject } from "../../infra/errors.js";

// NEVER convert to top-level runtime imports - breaks browser/Vite builds

let os: typeof NodeOs | null = null;

}

if (failed) {

throw toLintErrorObject(failed, "Non-Error thrown");

throw toErrorObject(failed, "Non-Error thrown");

}

if (!sawCompletion) {

throw new Error("WebSocket stream closed before response.completed");

headers.set("session_id", requestId);

return headers;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

*/

import type { Server } from "node:http";

import { toErrorObject } from "../../../infra/errors.js";

import {

generateOAuthState,

generatePKCE,

if (!code) {

await withOAuthLoginAbort(manualPromise, options.signal, server.cancelWait);

if (manualError) {

throw toLintErrorObject(manualError, "Non-Error thrown");

throw toErrorObject(manualError, "Non-Error thrown");

}

if (manualInput) {

const parsed = parseOAuthAuthorizationInput(manualInput);

return credentials.access;

},

};

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { sanitizeForLog } from "../../packages/terminal-core/src/ansi.js";

import { resolveArchiveKind } from "../infra/archive.js";

import { formatErrorMessage } from "../infra/errors.js";

import { formatErrorMessage, toErrorObject } from "../infra/errors.js";

import { pathExists } from "../infra/fs-safe.js";

import { resolveOsHomeRelativePath } from "../infra/home-dir.js";

import { tryReadJson } from "../infra/json-files.js";

(err: unknown) => {

clear();

if (!timedOut) {

reject(toLintErrorObject(err, "Non-Error rejection"));

reject(toErrorObject(err, "Non-Error rejection"));

}

},

);

await loaded.marketplace.cleanup?.();

}

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}

import { appendFileSync } from "node:fs";

import * as nodePty from "@lydell/node-pty";

import type { PtyExitEvent, PtyHandle } from "@lydell/node-pty";

import { toErrorObject } from "../infra/errors.js";

// Shared PTY harness utilities for fake-backend and local TUI smoke tests.

type NodePtyRuntimeModule = typeof nodePty & {

try {

result = params.read();

} catch (error) {

reject(toLintErrorObject(error, "Non-Error rejection"));

reject(toErrorObject(error, "Non-Error rejection"));

return;

}

if (result !== null) {

opts.activeRuns?.push(run);

return run;

}

function toLintErrorObject(value: unknown, fallbackMessage: string): Error {

if (value instanceof Error) {

return value;

}

if (typeof value === "string") {

return new Error(value);

}

const error = new Error(fallbackMessage, { cause: value });

if ((typeof value === "object" && value !== null) || typeof value === "function") {

Object.assign(error, value);

}

return error;

}