codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/runner/responses.d.ts

@@ -0,0 +1,30 @@
+import type { RunReportOptions } from "../commands/reports.js";
+import type { BootstrapArgs, ResponseFormat } from "../types.js";
+import type { ChatGPTAttachmentInput, ChatGPTInputItem, ChatGPTResponse, ChatGPTRunInput, ChatGPTRunResult, ChatGPTThreadSelector, ChatGPTVisibleModePreference, ChatGPTVisibleToolPreference, UnsupportedField } from "./types.js";
+export type ChatGPTResponsesCreateArgs = {
+    input: string | ChatGPTInputItem[];
+    thread?: ChatGPTThreadSelector;
+    existingTab?: BootstrapArgs["existingTab"];
+    preferExistingTab?: boolean;
+    attachments?: ChatGPTAttachmentInput[];
+    mode?: ChatGPTVisibleModePreference;
+    tools?: ChatGPTVisibleToolPreference[];
+    text?: {
+        format?: ResponseFormat;
+    };
+    stream?: false;
+    report?: boolean | RunReportOptions;
+    instructions?: string;
+    instructionsMode?: "visible_prefix";
+};
+export type ResponsesValidationResult = {
+    ok: true;
+    unsupported: [];
+} | {
+    ok: false;
+    unsupported: UnsupportedField[];
+};
+export declare function validateResponsesCreateArgs(args: Record<string, unknown>): ResponsesValidationResult;
+export declare function responsesCreateArgsToRunInput(args: ChatGPTResponsesCreateArgs): ChatGPTRunInput;
+export declare function responseFromRunResult<TOutput>(result: ChatGPTRunResult<TOutput>, now?: Date): ChatGPTResponse;
+export declare function unsupportedResponse(unsupported: UnsupportedField[], now?: Date): ChatGPTResponse;

package/dist/src/runner/responses.js

@@ -0,0 +1,171 @@
+const acceptedTopLevelFields = new Set([
+    "input",
+    "thread",
+    "existingTab",
+    "preferExistingTab",
+    "attachments",
+    "mode",
+    "tools",
+    "text",
+    "stream",
+    "report",
+    "instructions",
+    "instructionsMode"
+]);
+const unsupportedAlternatives = {
+    model: "Use mode for visible ChatGPT UI mode preference. This does not select an API model.",
+    temperature: "No browser-control equivalent. ChatGPT web does not expose API temperature.",
+    top_p: "No browser-control equivalent. ChatGPT web does not expose API nucleus sampling.",
+    seed: "No browser-control equivalent. Visible ChatGPT web does not expose deterministic API seeds.",
+    logprobs: "No browser-control equivalent. Visible ChatGPT web does not expose token log probabilities.",
+    top_logprobs: "No browser-control equivalent. Visible ChatGPT web does not expose token log probabilities.",
+    previous_response_id: "Use thread: { type: \"conversationId\", conversationId } or a ChatGPT thread URL.",
+    store: "No browser-control equivalent. Use visible ChatGPT settings or temporary chat controls when implemented.",
+    service_tier: "No browser-control equivalent. Visible ChatGPT web does not expose API service tiers.",
+    max_output_tokens: "Use response.maxChars/read maxChars for capture limits. This does not control model generation.",
+    parallel_tool_calls: "No browser-control equivalent. Visible ChatGPT browser control selects visible tools sequentially.",
+    truncation: "No browser-control equivalent. Use prompt design and response capture limits instead."
+};
+const responseFormats = new Set([
+    "markdown",
+    "text",
+    "normalized_text",
+    "visible_text",
+    "html",
+    "blocks",
+    "all"
+]);
+export function validateResponsesCreateArgs(args) {
+    const unsupported = [];
+    for (const [path, alternative] of Object.entries(unsupportedAlternatives)) {
+        if (args[path] !== undefined) {
+            unsupported.push(apiOnlyField(path, alternative));
+        }
+    }
+    for (const path of Object.keys(args)) {
+        if (!acceptedTopLevelFields.has(path) && unsupportedAlternatives[path] === undefined) {
+            unsupported.push({
+                path,
+                reason: "This field is not part of the narrow ChatGPT browser-control Responses adapter.",
+                alternative: "Use chatgpt.runner.run(...) for lower-level browser-control options."
+            });
+        }
+    }
+    if (args.input === undefined) {
+        unsupported.push({
+            path: "input",
+            reason: "Responses adapter calls must include visible input text or input items.",
+            alternative: "Provide input: \"your visible prompt\"."
+        });
+    }
+    if (args.stream !== undefined && args.stream !== false) {
+        unsupported.push({
+            path: "stream",
+            reason: "This adapter stage supports only non-streaming calls.",
+            alternative: "Set stream: false, or use the runner milestone stream when enabled."
+        });
+    }
+    if (args.instructions !== undefined && args.instructionsMode !== "visible_prefix") {
+        unsupported.push({
+            path: "instructions",
+            reason: "Responses API instructions are hidden context, but ChatGPT browser control can only submit visible text.",
+            alternative: "Set instructionsMode: \"visible_prefix\" to send instructions visibly."
+        });
+    }
+    if (args.instructionsMode !== undefined && args.instructionsMode !== "visible_prefix") {
+        unsupported.push({
+            path: "instructionsMode",
+            reason: "Only explicit visible-prefix instructions are supported by this adapter.",
+            alternative: "Use instructionsMode: \"visible_prefix\" or omit instructionsMode."
+        });
+    }
+    if (isRecord(args.text)) {
+        const format = args.text.format;
+        if (format !== undefined && (typeof format !== "string" || !responseFormats.has(format))) {
+            unsupported.push({
+                path: "text.format",
+                reason: "The requested response text format is not supported by ChatGPT browser-control capture.",
+                alternative: "Use markdown, visible_text, normalized_text, html, blocks, or all."
+            });
+        }
+        for (const path of Object.keys(args.text)) {
+            if (path !== "format") {
+                unsupported.push({
+                    path: `text.${path}`,
+                    reason: "Only text.format is supported by the narrow Responses adapter.",
+                    alternative: "Use chatgpt.runner.run(...) for lower-level browser-control options."
+                });
+            }
+        }
+    }
+    return unsupported.length === 0 ? { ok: true, unsupported: [] } : { ok: false, unsupported };
+}
+export function responsesCreateArgsToRunInput(args) {
+    const runInput = {
+        input: args.input,
+        response: { format: args.text?.format ?? "markdown" }
+    };
+    if (args.thread !== undefined)
+        runInput.thread = args.thread;
+    if (args.existingTab !== undefined)
+        runInput.existingTab = args.existingTab;
+    if (args.preferExistingTab !== undefined)
+        runInput.preferExistingTab = args.preferExistingTab;
+    if (args.attachments !== undefined)
+        runInput.attachments = args.attachments;
+    if (args.mode !== undefined)
+        runInput.mode = args.mode;
+    if (args.tools !== undefined)
+        runInput.tools = args.tools;
+    if (args.report !== undefined)
+        runInput.report = args.report;
+    return runInput;
+}
+export function responseFromRunResult(result, now = new Date()) {
+    const browserControl = {
+        visibleUi: true,
+        resultStatus: result.status
+    };
+    if (result.data?.thread !== undefined)
+        browserControl.thread = result.data.thread;
+    const reportPath = result.data?.reportPath ?? result.reportPath;
+    if (reportPath !== undefined)
+        browserControl.reportPath = reportPath;
+    return {
+        id: responseId(now),
+        object: "chatgpt.browser.response",
+        created_at: Math.floor(now.getTime() / 1000),
+        status: result.status,
+        output_text: result.output_text,
+        output: result.output,
+        browser_control: browserControl
+    };
+}
+export function unsupportedResponse(unsupported, now = new Date()) {
+    return {
+        id: responseId(now),
+        object: "chatgpt.browser.response",
+        created_at: Math.floor(now.getTime() / 1000),
+        status: "unsupported",
+        output_text: "",
+        output: [],
+        browser_control: {
+            visibleUi: true,
+            resultStatus: "unsupported",
+            unsupported
+        }
+    };
+}
+function apiOnlyField(path, alternative) {
+    return {
+        path,
+        reason: "This is an OpenAI API field that visible ChatGPT browser control cannot honestly support.",
+        alternative
+    };
+}
+function responseId(now) {
+    return `chatgpt-browser-${now.getTime().toString(36)}`;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/runner/result.d.ts

@@ -0,0 +1,3 @@
+import type { CommandResult } from "../types.js";
+import type { ChatGPTAgent, ChatGPTRunResult } from "./types.js";
+export declare function toRunResult<TOutput>(agent: ChatGPTAgent<TOutput>, result: CommandResult<unknown>): ChatGPTRunResult<TOutput>;

package/dist/src/runner/result.js

@@ -0,0 +1,128 @@
+import { interruptionFromCommandResult } from "./interruptions.js";
+import { augmentCommandBlocker } from "./resume.js";
+export function toRunResult(agent, result) {
+    const outputText = extractOutputText(result.data);
+    const finalOutput = parseFinalOutput(agent, outputText);
+    const interruption = interruptionFromCommandResult(result, failedCommand(result));
+    const interruptions = interruption === undefined ? [] : [interruption];
+    const output = runItemsFromResult(result, outputText);
+    const state = runStateFromResult(result, interruptions);
+    const data = { outputText };
+    if (finalOutput !== undefined)
+        data.finalOutput = finalOutput;
+    const thread = threadRefFromContext(result.context);
+    if (thread !== undefined)
+        data.thread = thread;
+    if (result.reportPath !== undefined)
+        data.reportPath = result.reportPath;
+    const mapped = {
+        ...result,
+        data,
+        output_text: outputText,
+        output,
+        newItems: output,
+        interruptions,
+        state,
+        activeAgentName: agent.name,
+        lastAgentName: agent.name
+    };
+    if (finalOutput !== undefined)
+        mapped.finalOutput = finalOutput;
+    return mapped;
+}
+function extractOutputText(data) {
+    if (!isRecord(data))
+        return "";
+    if (typeof data.responseText === "string")
+        return data.responseText;
+    if (typeof data.text === "string")
+        return data.text;
+    for (const value of Object.values(data)) {
+        const nested = extractOutputText(value);
+        if (nested.length > 0)
+            return nested;
+    }
+    return "";
+}
+function parseFinalOutput(agent, outputText) {
+    if (outputText.length === 0)
+        return undefined;
+    if (agent.output?.parse === "json") {
+        try {
+            return JSON.parse(outputText);
+        }
+        catch {
+            return agent.output.onParseError === "return_text" ? outputText : undefined;
+        }
+    }
+    return outputText;
+}
+function runItemsFromResult(result, outputText) {
+    const items = messageItemsFromData(result.data);
+    if (!items.some(item => item.type === "message.completed") && outputText.length > 0) {
+        items.push({ type: "message.completed", role: "assistant", output_text: outputText, format: "markdown" });
+    }
+    if (result.blocker !== undefined) {
+        items.push({ type: "run.blocked", blocker: augmentCommandBlocker(result.blocker) });
+    }
+    return items;
+}
+function messageItemsFromData(data) {
+    if (!isRecord(data))
+        return [];
+    const items = [];
+    if (typeof data.prompt === "string" && data.prompt.length > 0) {
+        items.push({
+            type: "message.submitted",
+            role: "user",
+            preview: data.prompt.length > 160 ? `${data.prompt.slice(0, 159)}...` : data.prompt,
+            redacted: true
+        });
+    }
+    if (typeof data.responseText === "string" && data.responseText.length > 0) {
+        items.push({ type: "message.completed", role: "assistant", output_text: data.responseText, format: "markdown" });
+    }
+    if (items.length > 0)
+        return items;
+    for (const value of Object.values(data)) {
+        const nested = messageItemsFromData(value);
+        if (nested.length > 0)
+            return nested;
+    }
+    return [];
+}
+function runStateFromResult(result, interruptions) {
+    const resumable = interruptions.some(interruption => interruption.resume.supported);
+    const firstResume = interruptions.find(interruption => interruption.resume.supported)?.resume;
+    const state = {
+        id: firstResume?.supported === true && firstResume.stateId !== undefined ? firstResume.stateId : `run_${Date.now().toString(36)}`,
+        resumable
+    };
+    const thread = threadRefFromContext(result.context);
+    if (thread !== undefined)
+        state.thread = thread;
+    return state;
+}
+function threadRefFromContext(context) {
+    const thread = {};
+    if (context.url !== undefined)
+        thread.url = context.url;
+    if (context.conversationId !== undefined)
+        thread.conversationId = context.conversationId;
+    if (context.title !== undefined)
+        thread.title = context.title;
+    return Object.keys(thread).length === 0 ? undefined : thread;
+}
+function failedCommand(result) {
+    if (result.steps === undefined)
+        return undefined;
+    for (let index = result.steps.length - 1; index >= 0; index -= 1) {
+        const step = result.steps[index];
+        if (step?.ok === false)
+            return step.command;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/src/runner/resume.d.ts

@@ -0,0 +1,11 @@
+import type { CommandResult } from "../types.js";
+import type { ChatGPTCommandBlocker } from "./types.js";
+export type ResumeDecision = {
+    supported: true;
+    stateId?: string;
+} | {
+    supported: false;
+    reason: string;
+};
+export declare function resumeDecisionForBlocker(blocker: CommandResult["blocker"] | undefined, stateId?: string): ResumeDecision;
+export declare function augmentCommandBlocker(blocker: NonNullable<CommandResult["blocker"]>): ChatGPTCommandBlocker;

package/dist/src/runner/resume.js

@@ -0,0 +1,26 @@
+const NEVER_AUTO_RESUME = new Set([
+    "captcha",
+    "login_required",
+    "rate_limit",
+    "selector_drift",
+    "unknown"
+]);
+export function resumeDecisionForBlocker(blocker, stateId) {
+    if (blocker === undefined) {
+        return { supported: false, reason: "This result has no resumable browser-control blocker." };
+    }
+    if (NEVER_AUTO_RESUME.has(blocker.kind)) {
+        return { supported: false, reason: "This blocker is not safe to resume automatically." };
+    }
+    if (blocker.resumable === true) {
+        return stateId === undefined ? { supported: true } : { supported: true, stateId };
+    }
+    return { supported: false, reason: "The underlying browser-control command did not mark this blocker as resumable." };
+}
+export function augmentCommandBlocker(blocker) {
+    const augmented = { ...blocker };
+    if (augmented.resumable === undefined) {
+        augmented.resumable = blocker.kind === "confirmation" || blocker.kind === "permission";
+    }
+    return augmented;
+}

package/dist/src/runner/stream.d.ts

@@ -0,0 +1,13 @@
+import type { ChatGPTRunItem, ChatGPTRunResult } from "./types.js";
+export type ChatGPTRunStreamEventName = "thread_opened" | "mode_selected" | "tool_selected" | "file_attached" | "message_submitted" | "message_completed" | "file_downloaded" | "run_blocked";
+export type ChatGPTRunStreamEvent = {
+    type: "run_item_stream_event";
+    name: ChatGPTRunStreamEventName;
+    item: ChatGPTRunItem;
+};
+export type ChatGPTRunStream<TOutput = string> = AsyncIterable<ChatGPTRunStreamEvent> & {
+    completed: Promise<ChatGPTRunResult<TOutput>>;
+};
+export declare function createMilestoneStream<TOutput = string>(run: (emit: (event: ChatGPTRunStreamEvent) => void) => Promise<ChatGPTRunResult<TOutput>>): ChatGPTRunStream<TOutput>;
+export declare function streamFromRunResult<TOutput>(run: () => Promise<ChatGPTRunResult<TOutput>>): ChatGPTRunStream<TOutput>;
+export declare function runItemStreamEvent(item: ChatGPTRunItem): ChatGPTRunStreamEvent;

package/dist/src/runner/stream.js

@@ -0,0 +1,66 @@
+export function createMilestoneStream(run) {
+    const queue = [];
+    let resolveNext;
+    let finished = false;
+    const completed = run(event => {
+        queue.push(event);
+        resolveNext?.();
+        resolveNext = undefined;
+    }).finally(() => {
+        finished = true;
+        resolveNext?.();
+        resolveNext = undefined;
+    });
+    return {
+        completed,
+        async *[Symbol.asyncIterator]() {
+            while (!finished || queue.length > 0) {
+                const next = queue.shift();
+                if (next !== undefined) {
+                    yield next;
+                    continue;
+                }
+                await new Promise(resolve => {
+                    resolveNext = resolve;
+                });
+            }
+        }
+    };
+}
+export function streamFromRunResult(run) {
+    return createMilestoneStream(async (emit) => {
+        const result = await run();
+        for (const item of result.newItems) {
+            emit(runItemStreamEvent(item));
+        }
+        return result;
+    });
+}
+export function runItemStreamEvent(item) {
+    return {
+        type: "run_item_stream_event",
+        name: runItemEventName(item),
+        item
+    };
+}
+function runItemEventName(item) {
+    switch (item.type) {
+        case "thread.opened":
+            return "thread_opened";
+        case "mode.selected":
+            return "mode_selected";
+        case "tool.selected":
+            return "tool_selected";
+        case "file.attached":
+            return "file_attached";
+        case "message.submitted":
+            return "message_submitted";
+        case "message.completed":
+            return "message_completed";
+        case "file.downloaded":
+            return "file_downloaded";
+        case "approval.required":
+        case "run.blocked":
+            return "run_blocked";
+    }
+}