hyperbrane 0.1.0 → 0.1.2

package/dist/agent/session/worker/workerParams.js

@@ -0,0 +1,163 @@
+import { AGENT_BACKENDS, AgentInvalidError, } from "../../api.js";
+/**
+ * Turns each method's params, as they arrived (JSON), into the protocol's types, or throws an
+ * AgentInvalidError saying what's wrong. Keeps only the fields the types have, so nothing unknown
+ * reaches the service (or its storage).
+ */
+export const WORKER_PARAMS = {
+    "worker/health": () => ({}),
+    "worker/shutdown": () => ({}),
+    "backend/install": (params) => ({ backend: backend(params.backend) }),
+    "backend/list": () => ({}),
+    "session/create": (params) => ({ session: session(object(params.session, "session")) }),
+    "session/list": () => ({}),
+    "session/update": (params) => ({ session: name(params), limits: limits(object(params.limits, "limits")) }),
+    "session/stop": (params) => ({ session: name(params) }),
+    "session/send": (params) => ({ session: name(params), message: userMessage(params.message) }),
+    "session/interrupt": (params) => ({ session: name(params) }),
+    "session/status": (params) => ({ session: name(params) }),
+    "session/lastUserMessages": (params) => ({ session: name(params) }),
+    "session/subscribe": (params) => ({
+        session: name(params),
+        subscription: text(params.subscription, "subscription"),
+        after_id: optional(params.after_id, (value) => text(value, "after_id")),
+    }),
+    "session/unsubscribe": (params) => ({ subscription: text(params.subscription, "subscription") }),
+    "session/transcript": (params) => ({
+        session: name(params),
+        limit: optional(params.limit, (value) => number(value, "limit")),
+        // `cursor`: `before`'s old name.
+        before: params.before === undefined ? optional(params.cursor, (value) => text(value, "cursor")) : text(params.before, "before"),
+    }),
+    "permission/list": (params) => ({ session: name(params) }),
+    "permission/respond": (params) => ({
+        session: name(params),
+        request: text(params.request, "request"),
+        result: permissionResult(params.result),
+    }),
+    "question/list": (params) => ({ session: name(params) }),
+    "question/respond": (params) => ({
+        session: name(params),
+        request: text(params.request, "request"),
+        response: questionResponse(params.response),
+    }),
+    "model/list": (params) => ({ session: name(params) }),
+    "model/set": (params) => ({
+        session: name(params),
+        model: params.model === null ? null : text(params.model, "the model (a model name, or null for the backend's default)"),
+    }),
+    "task/list": (params) => ({ session: name(params) }),
+    "task/stop": (params) => ({ session: name(params), task: text(params.task, "task") }),
+    "auth/status": (params) => ({ session: name(params) }),
+    "auth/login": (params) => ({
+        session: name(params),
+        gatewaySignedIn: optional(params.gatewaySignedIn, (value) => boolean(value, "gatewaySignedIn")) ?? false,
+    }),
+    "auth/code": (params) => ({ session: name(params), code: text(params.code, "the code (the one the sign-in page showed)").trim() }),
+};
+function invalid(message) {
+    throw new AgentInvalidError(message);
+}
+function name(params) {
+    return text(params.session, "session");
+}
+function object(value, what) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        invalid(`${what} must be an object`);
+    // type-bypass: a non-null, non-array object is a record of its fields.
+    return value;
+}
+/** A non-empty string. */
+function text(value, what) {
+    if (typeof value !== "string" || value.trim() === "")
+        invalid(`${what} must be a non-empty string`);
+    return value;
+}
+function number(value, what) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        invalid(`${what} must be a number`);
+    return value;
+}
+function boolean(value, what) {
+    if (typeof value !== "boolean")
+        invalid(`${what} must be true or false`);
+    return value;
+}
+function optional(value, parse) {
+    return value === undefined ? undefined : parse(value);
+}
+function backend(value) {
+    const known = AGENT_BACKENDS.find((name) => name === value);
+    if (!known)
+        invalid(`unknown backend "${String(value)}"; known: ${AGENT_BACKENDS.join(", ")}`);
+    return known;
+}
+function memoryLimit(value) {
+    const bytes = number(value, "memoryLimit");
+    if (!(bytes > 0))
+        invalid("memoryLimit must be positive");
+    // type-bypass: a positive byte count is what a MemoryLimit is (MemoryLimit() parses the CLI's strings).
+    return bytes;
+}
+function cpuLimit(value) {
+    const cores = number(value, "cpuLimit");
+    if (!(cores > 0))
+        invalid("cpuLimit must be positive");
+    // type-bypass: a positive core count is what a CPULimit is (CPULimit() parses the CLI's strings).
+    return cores;
+}
+function environment(value) {
+    const fields = object(value, "env");
+    for (const [key, entry] of Object.entries(fields))
+        if (typeof entry !== "string")
+            invalid(`env.${key} must be a string`);
+    // type-bypass: every value was just checked to be a string.
+    return fields;
+}
+function session(fields) {
+    return {
+        name: text(fields.name, "the session's name"),
+        backend: backend(fields.backend),
+        memoryLimit: memoryLimit(fields.memoryLimit),
+        cpuLimit: cpuLimit(fields.cpuLimit),
+        cwd: optional(fields.cwd, (value) => text(value, "cwd")),
+        env: optional(fields.env, environment),
+    };
+}
+function limits(fields) {
+    return { memoryLimit: optional(fields.memoryLimit, memoryLimit), cpuLimit: optional(fields.cpuLimit, cpuLimit) };
+}
+function userMessage(value) {
+    const fields = object(value, "a message (an SDK user message: {type: \"user\", message})");
+    if (fields.type !== "user")
+        invalid('a message is an SDK user message: {type: "user", message}');
+    const message = object(fields.message, "message.message");
+    if (message.role !== "user")
+        invalid('message.message.role must be "user"');
+    if (typeof message.content !== "string" && !Array.isArray(message.content))
+        invalid("message.message.content must be a string or an array of content blocks");
+    // type-bypass: the envelope is checked; the content blocks are the CLI's to judge.
+    return value;
+}
+function permissionResult(value) {
+    const fields = object(value, "result");
+    if (fields.behavior === "allow") {
+        return { behavior: "allow", updatedInput: optional(fields.updatedInput, (input) => object(input, "updatedInput")) };
+    }
+    if (fields.behavior === "deny") {
+        return {
+            behavior: "deny",
+            message: typeof fields.message === "string" ? fields.message : invalid("a denial needs a message"),
+            interrupt: optional(fields.interrupt, (interrupt) => boolean(interrupt, "interrupt")),
+        };
+    }
+    return invalid('a permission result is {behavior: "allow"} or {behavior: "deny", message}');
+}
+function questionResponse(value) {
+    const answers = object(object(value, "response").answers, "a question response's answers ({<question>: <answer>})");
+    for (const [question, answer] of Object.entries(answers))
+        if (typeof answer !== "string")
+            invalid(`the answer to "${question}" must be a string`);
+    // type-bypass: every answer was just checked to be a string.
+    return { answers: answers };
+}

package/dist/agent/session/workerSseConnection.d.ts

@@ -5,11 +5,27 @@ export { EndpointLoginRequiredError, exeDevLoginUrl, sseEvents } from "../../san
 export type WorkerEndpoint = Pick<SandboxEndpoint, "url" | "credentials">;
 /**
  * Connects to a worker through its accessible endpoint (AgentService.exposeAgent: the endpoint
- * proxy's "sse" transport), each connection an openSseConnection. Given a function, it asks it for
- * the endpoint before every connection, so a proxy that stopped is started again (exposeAgent does
- * that) before the client needs it. Runs in a browser as well as on a server. Aborting `signal`
- * closes every connection it opened (a stream waiting for the next message included).
+ * proxy's "sse" transport), each connection an openSseConnection. Runs in a browser as well as on a
+ * server. Aborting `signal` closes every connection it opened (a stream waiting for the next message
+ * included).
+ *
+ * Given a function (one that calls exposeAgent, through the page's server), it asks it once and
+ * keeps the endpoint; when a connection fails to open it asks again, which starts a proxy that
+ * stopped (an archived and resumed Boat sandbox, a reboot) at the same URL, and retries once. If that
+ * fails too it throws EndpointUnreachableError (or EndpointLoginRequiredError, for an exe.dev
+ * endpoint). Given an endpoint, it uses it as it is: one that stopped being served just fails.
  */
 export declare function workerSseConnector(endpoint: WorkerEndpoint | (() => Promise<WorkerEndpoint>), { signal }?: {
     signal?: AbortSignal;
 }): ConnectWorker;
+/**
+ * The worker's endpoint didn't answer, even once exposed again. A browser reports that as a CORS
+ * error whatever the cause: the page's origin isn't among the endpoint's allowedOrigins (give it to
+ * exposeAgent), or nothing answers at the endpoint's URL (the machine is unreachable, or the
+ * endpoint was closed).
+ */
+export declare class EndpointUnreachableError extends Error {
+    readonly url: string;
+    name: string;
+    constructor(url: string, cause?: unknown);
+}

package/dist/agent/session/workerSseConnection.js

@@ -1,18 +1,53 @@
-import { openSseConnection } from "../../sandbox/sseConnection.js";
+import { EndpointLoginRequiredError, openSseConnection } from "../../sandbox/sseConnection.js";
 import { workerConnectionOver } from "./workerConnection.js";
 export { EndpointLoginRequiredError, exeDevLoginUrl, sseEvents } from "../../sandbox/sseConnection.js";
 /**
  * Connects to a worker through its accessible endpoint (AgentService.exposeAgent: the endpoint
- * proxy's "sse" transport), each connection an openSseConnection. Given a function, it asks it for
- * the endpoint before every connection, so a proxy that stopped is started again (exposeAgent does
- * that) before the client needs it. Runs in a browser as well as on a server. Aborting `signal`
- * closes every connection it opened (a stream waiting for the next message included).
+ * proxy's "sse" transport), each connection an openSseConnection. Runs in a browser as well as on a
+ * server. Aborting `signal` closes every connection it opened (a stream waiting for the next message
+ * included).
+ *
+ * Given a function (one that calls exposeAgent, through the page's server), it asks it once and
+ * keeps the endpoint; when a connection fails to open it asks again, which starts a proxy that
+ * stopped (an archived and resumed Boat sandbox, a reboot) at the same URL, and retries once. If that
+ * fails too it throws EndpointUnreachableError (or EndpointLoginRequiredError, for an exe.dev
+ * endpoint). Given an endpoint, it uses it as it is: one that stopped being served just fails.
  */
 export function workerSseConnector(endpoint, { signal } = {}) {
+    let kept = null;
+    const current = (fresh) => {
+        if (typeof endpoint !== "function")
+            return Promise.resolve(endpoint);
+        if (fresh || !kept) {
+            const asked = endpoint();
+            kept = asked;
+            asked.catch(() => kept === asked && (kept = null));
+        }
+        return kept;
+    };
+    async function open() {
+        const first = await current(false);
+        try {
+            return [first, await openSseConnection(first, { signal })];
+        }
+        catch (error) {
+            if (typeof endpoint !== "function" || signal?.aborted)
+                throw error;
+        }
+        // Asked again unless another connection already did since.
+        const access = kept && (await kept) !== first ? await kept : await current(true);
+        try {
+            return [access, await openSseConnection(access, { signal })];
+        }
+        catch (error) {
+            if (signal?.aborted || error instanceof EndpointLoginRequiredError)
+                throw error;
+            throw new EndpointUnreachableError(access.url, error);
+        }
+    }
     return async (onNotification) => {
         signal?.throwIfAborted();
-        const access = typeof endpoint === "function" ? await endpoint() : endpoint;
-        const connection = await openSseConnection(access, { signal });
+        const [access, connection] = await open();
         const decoder = new TextDecoder();
         const encoder = new TextEncoder();
         const transport = {
@@ -24,3 +59,18 @@ export function workerSseConnector(endpoint, { signal } = {}) {
         return workerConnectionOver(transport, access.url.replace(/\/+$/, ""), onNotification);
     };
 }
+/**
+ * The worker's endpoint didn't answer, even once exposed again. A browser reports that as a CORS
+ * error whatever the cause: the page's origin isn't among the endpoint's allowedOrigins (give it to
+ * exposeAgent), or nothing answers at the endpoint's URL (the machine is unreachable, or the
+ * endpoint was closed).
+ */
+export class EndpointUnreachableError extends Error {
+    url;
+    name = "EndpointUnreachableError";
+    constructor(url, cause) {
+        super(`the agent's endpoint ${url} didn't answer, even once exposed again (a browser reports this as a CORS error): ` +
+            "is the page's origin among its allowedOrigins, and is the machine reachable?", { cause });
+        this.url = url;
+    }
+}

package/dist/agent/vendor-types/codex/app-server/AbsolutePathBuf.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A path that is guaranteed to be absolute and normalized (though it is not
+ * guaranteed to be canonicalized or exist on the filesystem).
+ *
+ * IMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set
+ * using [AbsolutePathBufGuard::new]. If no base path is set, the
+ * deserialization will fail unless the path being deserialized is already
+ * absolute.
+ */
+export type AbsolutePathBuf = string;

package/dist/agent/vendor-types/codex/app-server/AbsolutePathBuf.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/FunctionCallOutputBody.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionCallOutputContentItem } from "./FunctionCallOutputContentItem";
+export type FunctionCallOutputBody = string | Array<FunctionCallOutputContentItem>;

package/dist/agent/vendor-types/codex/app-server/FunctionCallOutputBody.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/FunctionCallOutputContentItem.d.ts

@@ -0,0 +1,22 @@
+import type { ImageDetail } from "./ImageDetail";
+/**
+ * Responses API compatible content items that can be returned by a tool call.
+ * This is a subset of ContentItem with the types we support as function call outputs.
+ */
+export type FunctionCallOutputContentItem = {
+    "type": "input_text";
+    text: string;
+} | {
+    "type": "input_image";
+    detail?: ImageDetail;
+} & ({
+    image_url: string;
+} | {
+    file_id: string;
+}) | {
+    "type": "input_audio";
+    audio_url: string;
+} | {
+    "type": "encrypted_content";
+    encrypted_content: string;
+};

package/dist/agent/vendor-types/codex/app-server/FunctionCallOutputContentItem.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/ImageDetail.d.ts

@@ -0,0 +1 @@
+export type ImageDetail = "auto" | "low" | "high" | "original";

package/dist/agent/vendor-types/codex/app-server/ImageDetail.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/ImageGenerationFailure.d.ts

@@ -0,0 +1,5 @@
+export type ImageGenerationFailure = {
+    "type": "usageLimitExceeded";
+    limitId: string;
+    resetsAt: number | null;
+};

package/dist/agent/vendor-types/codex/app-server/ImageGenerationFailure.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/ImageGenerationItem.d.ts

@@ -0,0 +1,11 @@
+import type { AbsolutePathBuf } from "./AbsolutePathBuf";
+import type { ImageGenerationFailure } from "./ImageGenerationFailure";
+export type ImageGenerationItem = {
+    id: string;
+    status: string;
+    revisedPrompt: string | null;
+    result: string;
+    transparentBackground?: boolean;
+    failure: ImageGenerationFailure | null;
+    savedPath?: AbsolutePathBuf;
+};

package/dist/agent/vendor-types/codex/app-server/ImageGenerationItem.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/LegacyAppPathString.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A UTF-8 path for preserving raw path compatibility at the app-server API
+ * boundary while Codex migrates to [`PathUri`].
+ *
+ * Supports storing arbitrary strings read from the API and converting to and
+ * from [`PathUri`] using an explicitly selected native path convention.
+ *
+ * When converting from [`PathUri`], "native" refers to the supplied
+ * [`PathConvention`], which may be foreign to the operating system running
+ * this process. The inner string is private so path-producing code must use a
+ * path conversion method instead of bypassing the intended conversion
+ * boundary. Non-UTF-8 paths are converted to UTF-8 lossily because this API
+ * value is serialized as a JSON string.
+ *
+ * Deserialization and [`Self::from_string`] accept any UTF-8 string without
+ * interpreting or validating it. Use [`Self::from_string`] when a caller
+ * already owns legacy app-server path text and needs to preserve its wire
+ * spelling; use [`Self::from_path`], [`Self::from_abs_path`], or
+ * [`Self::from_path_uri`] when converting an actual path value. Relative
+ * path text remains valid until an operation such as [`Self::to_path_uri`]
+ * requires an absolute path.
+ */
+export type LegacyAppPathString = string;

package/dist/agent/vendor-types/codex/app-server/LegacyAppPathString.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/MessagePhase.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Classifies an assistant message as interim commentary or final answer text.
+ *
+ * Providers do not emit this consistently, so callers must treat `None` as
+ * "phase unknown" and keep compatibility behavior for legacy models.
+ */
+export type MessagePhase = "commentary" | "final_answer";

package/dist/agent/vendor-types/codex/app-server/MessagePhase.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/ReasoningEffort.d.ts

@@ -0,0 +1,4 @@
+/**
+ * See https://platform.openai.com/docs/guides/reasoning?api-mode=responses#get-started-with-reasoning
+ */
+export type ReasoningEffort = string;

package/dist/agent/vendor-types/codex/app-server/ReasoningEffort.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/SleepItem.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Display item emitted by the interruptible `clock.sleep` tool.
+ */
+export type SleepItem = {
+    id: string;
+    durationMs: number;
+};

package/dist/agent/vendor-types/codex/app-server/SleepItem.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/WebSearchItem.d.ts

@@ -0,0 +1,14 @@
+import type { JsonValue } from "./serde_json/JsonValue";
+import type { WebSearchAction } from "./v2/WebSearchAction";
+export type WebSearchItem = {
+    id: string;
+    query: string;
+    action: WebSearchAction | null;
+    /**
+     * Structured search results returned out-of-band by standalone web search.
+     *
+     * These stay as opaque JSON at the extension/app-server boundary so new
+     * result fields and result types can pass through without a Codex release.
+     */
+    results: Array<JsonValue> | null;
+};

package/dist/agent/vendor-types/codex/app-server/WebSearchItem.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/serde_json/JsonValue.d.ts

@@ -0,0 +1,3 @@
+export type JsonValue = number | string | boolean | Array<JsonValue> | {
+    [key in string]?: JsonValue;
+} | null;

package/dist/agent/vendor-types/codex/app-server/serde_json/JsonValue.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/AgentMessageDelivery.d.ts

@@ -0,0 +1 @@
+export type AgentMessageDelivery = "async";

package/dist/agent/vendor-types/codex/app-server/v2/AgentMessageDelivery.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/AsyncUserInputQuestion.d.ts

@@ -0,0 +1,4 @@
+export type AsyncUserInputQuestion = {
+    title: string;
+    options: Array<string> | null;
+};

package/dist/agent/vendor-types/codex/app-server/v2/AsyncUserInputQuestion.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/ByteRange.d.ts

@@ -0,0 +1,4 @@
+export type ByteRange = {
+    start: number;
+    end: number;
+};

package/dist/agent/vendor-types/codex/app-server/v2/ByteRange.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentState.d.ts

@@ -0,0 +1,5 @@
+import type { CollabAgentStatus } from "./CollabAgentStatus";
+export type CollabAgentState = {
+    status: CollabAgentStatus;
+    message: string | null;
+};

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentState.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentStatus.d.ts

@@ -0,0 +1 @@
+export type CollabAgentStatus = "pendingInit" | "running" | "interrupted" | "completed" | "errored" | "shutdown" | "notFound";

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentStatus.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentTool.d.ts

@@ -0,0 +1 @@
+export type CollabAgentTool = "spawnAgent" | "sendInput" | "resumeAgent" | "wait" | "closeAgent" | "sendMessage" | "followupTask" | "interruptAgent" | "listAgents";

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentTool.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentToolCallStatus.d.ts

@@ -0,0 +1 @@
+export type CollabAgentToolCallStatus = "inProgress" | "completed" | "failed" | "interrupted";

package/dist/agent/vendor-types/codex/app-server/v2/CollabAgentToolCallStatus.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CommandAction.d.ts

@@ -0,0 +1,19 @@
+import type { LegacyAppPathString } from "../LegacyAppPathString";
+export type CommandAction = {
+    "type": "read";
+    command: string;
+    name: string;
+    path: LegacyAppPathString;
+} | {
+    "type": "listFiles";
+    command: string;
+    path: string | null;
+} | {
+    "type": "search";
+    command: string;
+    query: string | null;
+    path: string | null;
+} | {
+    "type": "unknown";
+    command: string;
+};

package/dist/agent/vendor-types/codex/app-server/v2/CommandAction.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CommandExecutionSource.d.ts

@@ -0,0 +1 @@
+export type CommandExecutionSource = "agent" | "userShell" | "unifiedExecStartup" | "unifiedExecInteraction";

package/dist/agent/vendor-types/codex/app-server/v2/CommandExecutionSource.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/CommandExecutionStatus.d.ts

@@ -0,0 +1 @@
+export type CommandExecutionStatus = "inProgress" | "completed" | "failed" | "declined";

package/dist/agent/vendor-types/codex/app-server/v2/CommandExecutionStatus.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/DynamicToolCallOutputContentItem.d.ts

@@ -0,0 +1,10 @@
+export type DynamicToolCallOutputContentItem = {
+    "type": "inputText";
+    text: string;
+} | {
+    "type": "inputImage";
+    imageUrl: string;
+} | {
+    "type": "inputAudio";
+    audioUrl: string;
+};

package/dist/agent/vendor-types/codex/app-server/v2/DynamicToolCallOutputContentItem.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/DynamicToolCallStatus.d.ts

@@ -0,0 +1 @@
+export type DynamicToolCallStatus = "inProgress" | "completed" | "failed";

package/dist/agent/vendor-types/codex/app-server/v2/DynamicToolCallStatus.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/FileUpdateChange.d.ts

@@ -0,0 +1,6 @@
+import type { PatchChangeKind } from "./PatchChangeKind";
+export type FileUpdateChange = {
+    path: string;
+    kind: PatchChangeKind;
+    diff: string;
+};

package/dist/agent/vendor-types/codex/app-server/v2/FileUpdateChange.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/HookPromptFragment.d.ts

@@ -0,0 +1,4 @@
+export type HookPromptFragment = {
+    text: string;
+    hookRunId: string;
+};

package/dist/agent/vendor-types/codex/app-server/v2/HookPromptFragment.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/McpAppDisplayMode.d.ts

@@ -0,0 +1 @@
+export type McpAppDisplayMode = "inline" | "fullscreen";

package/dist/agent/vendor-types/codex/app-server/v2/McpAppDisplayMode.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};

package/dist/agent/vendor-types/codex/app-server/v2/McpAppUi.d.ts

@@ -0,0 +1,8 @@
+import type { McpAppDisplayMode } from "./McpAppDisplayMode";
+/**
+ * UI resource and display preference for model invocations, captured from the tool descriptor.
+ */
+export type McpAppUi = {
+    resourceUri: string;
+    preferredModelDisplayMode: McpAppDisplayMode;
+};

package/dist/agent/vendor-types/codex/app-server/v2/McpAppUi.js

@@ -0,0 +1,2 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+export {};