@zhanguym/chatroom 1.0.0 → 1.1.0-beta.0

package/dist/plugins/agent/provider.d.ts

@@ -0,0 +1,132 @@
+import type { AgentAttachment, AgentError, AgentInteractionOption, AgentPlanStep, AgentSessionConfig, AgentTokenUsage, AgentFileChange, AgentInputQuestion, AgentInteractionResponse, AgentModel, AgentProviderFeatures, AgentProviderId, AgentProviderNativeSetting, AgentProviderProbe, AgentProviderDetails, AgentReviewTarget } from "./types.js";
+export interface AgentProviderContext extends AgentSessionConfig {
+    workspaceRoot: string;
+    workspacePrompt: string | null;
+    continuityContext: string | null;
+    continuityDelta: string | null;
+}
+export interface AgentProvider {
+    readonly id: AgentProviderId;
+    readonly displayName: string;
+    readonly icon: string | null;
+    readonly features: AgentProviderFeatures;
+    readonly nativeSettings: readonly AgentProviderNativeSetting[];
+    probe(): Promise<AgentProviderProbe>;
+    details(): Promise<AgentProviderDetails>;
+    listModels(): Promise<AgentModel[]>;
+    createSession(context: AgentProviderContext): Promise<ProviderSession>;
+    resumeSession(context: AgentProviderContext, providerSessionId: string): Promise<ProviderSession>;
+    close(): Promise<void>;
+}
+export interface ProviderSession {
+    readonly providerSessionId: string;
+    runTurn(input: ProviderTurnInput): AsyncIterable<ProviderEvent>;
+    runReview?(target: AgentReviewTarget): AsyncIterable<ProviderEvent>;
+    steer?(input: Pick<ProviderTurnInput, "text" | "attachments">): Promise<void>;
+    interrupt(): Promise<void>;
+    configure(config: AgentSessionConfig): Promise<void>;
+    resolveInteraction(interactionId: string, response: AgentInteractionResponse): Promise<void>;
+    close(): Promise<void>;
+}
+export interface ProviderTurnInput {
+    outputSchema: unknown | null;
+    text: string;
+    attachments: AgentAttachment[];
+}
+export type ProviderItem = {
+    type: "assistant_message";
+    text: string;
+    phase: "commentary" | "final_answer" | null;
+} | {
+    type: "command";
+    command: string;
+    cwd: string | null;
+    output: string;
+    exitCode: number | null;
+} | {
+    type: "tool";
+    progress: string | null;
+    name: string;
+    server: string | null;
+    input: unknown;
+    output: unknown;
+    error: string | null;
+} | {
+    type: "turn_diff";
+    diff: string;
+} | {
+    type: "file_change";
+    changes: AgentFileChange[];
+} | {
+    type: "plan";
+    text: string;
+    steps: AgentPlanStep[];
+} | {
+    type: "reasoning_summary";
+    text: string;
+} | {
+    type: "artifact";
+    artifact: {
+        kind: "image" | "file";
+        name: string;
+        path: string;
+        mimeType: string | null;
+    };
+} | {
+    type: "context_compaction";
+    trigger: "auto" | "manual" | null;
+    error: string | null;
+} | {
+    type: "notice";
+    level: "info" | "warning" | "error";
+    text: string;
+};
+export interface ProviderInteraction {
+    id: string;
+    kind: "approval" | "input";
+    title: string;
+    description: string | null;
+    questions: AgentInputQuestion[];
+    approvalOptions: AgentInteractionOption[];
+}
+export type ProviderEvent = {
+    type: "interaction.resolved";
+    providerRequestId: string;
+} | {
+    type: "token.usage";
+    usage: AgentTokenUsage;
+} | {
+    type: "model.rerouted";
+    fromModel: string;
+    toModel: string;
+    reason: string;
+} | {
+    type: "item.updated";
+    providerItemId: string;
+    item: ProviderItem;
+} | {
+    type: "turn.started";
+    providerTurnId: string | null;
+} | {
+    type: "item.started";
+    providerItemId: string;
+    item: ProviderItem;
+} | {
+    type: "item.delta";
+    providerItemId: string;
+    field: "text" | "output";
+    delta: string;
+} | {
+    type: "item.completed";
+    providerItemId: string;
+    item: ProviderItem;
+    failed?: boolean;
+} | {
+    type: "interaction.requested";
+    providerItemId: string;
+    interaction: ProviderInteraction;
+} | {
+    type: "turn.completed";
+    status: "completed" | "interrupted" | "failed";
+    error: AgentError | null;
+};

package/dist/plugins/agent/providers/codex/mapping.d.ts

@@ -0,0 +1,56 @@
+import type { AgentProviderContext, ProviderEvent, ProviderItem, ProviderSession, ProviderTurnInput } from "#plugins/agent/provider";
+import type { AgentError, AgentInputQuestion, AgentInteractionOption, AgentProviderDetails, AgentReviewTarget } from "#plugins/agent/types";
+import { CodexRpcClient } from "./rpc.js";
+type SessionConfig = Parameters<ProviderSession["configure"]>[0];
+type ApprovalChoice = AgentInteractionOption & {
+    result: unknown;
+};
+export declare function codexItem(item: Record<string, unknown>, workspaceRoot: string): ProviderItem | null;
+export declare function codexFileChanges(value: unknown): {
+    path: string;
+    kind: string;
+    movePath: string | null;
+    diff: string;
+}[];
+export declare function codexItemFailed(item: Record<string, unknown>): boolean;
+export declare function grantedPermissions(requested: Record<string, unknown>): Record<string, unknown>;
+export declare function codexQuestions(value: unknown): AgentInputQuestion[];
+export declare function stringOrNull(value: unknown): string | null;
+export declare function codexVersion(userAgent: string): string | null;
+export declare function injectWorkspacePrompt(client: CodexRpcClient, threadId: string, prompt: string | null): Promise<void>;
+export declare function injectContinuity(client: CodexRpcClient, threadId: string, context: string | null): Promise<void>;
+export declare function sessionConfig(context: AgentProviderContext): SessionConfig;
+export declare function standardApprovalChoices(): ApprovalChoice[];
+export declare function turnError(value: unknown): AgentError | null;
+export declare function codexAccountUsage(value: unknown): AgentProviderDetails["accountUsage"];
+export declare function tokenUsage(value: unknown): Extract<ProviderEvent, {
+    type: "token.usage";
+}>["usage"] | null;
+export declare function codexInput(input: Pick<ProviderTurnInput, "text" | "attachments">, workspaceRoot: string): unknown[];
+export declare function reviewTarget(target: AgentReviewTarget): {
+    type: "uncommittedChanges";
+    branch?: never;
+    sha?: never;
+    title?: never;
+    instructions?: never;
+} | {
+    type: "baseBranch";
+    branch: string;
+    sha?: never;
+    title?: never;
+    instructions?: never;
+} | {
+    type: "commit";
+    sha: string;
+    title: string | null;
+    branch?: never;
+    instructions?: never;
+} | {
+    type: "custom";
+    instructions: string;
+    branch?: never;
+    sha?: never;
+    title?: never;
+};
+export declare function codexWarning(method: string, params: Record<string, unknown>): string | null;
+export {};

package/dist/plugins/agent/providers/codex/mapping.js

@@ -0,0 +1,427 @@
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { array, questionOptions, record, stringifyOptional, continuityInstructions, workspaceInstructions, } from "../common.js";
+export function codexItem(item, workspaceRoot) {
+    const type = item.type;
+    if (type === "agentMessage")
+        return {
+            type: "assistant_message",
+            phase: item.phase === "commentary" || item.phase === "final_answer"
+                ? item.phase
+                : null,
+            text: typeof item.text === "string" ? item.text : "",
+        };
+    if (type === "contextCompaction")
+        return { type: "context_compaction", trigger: null, error: null };
+    if (type === "reasoning")
+        return {
+            type: "reasoning_summary",
+            text: array(item.summary)
+                .filter((part) => typeof part === "string")
+                .join("\n"),
+        };
+    if (type === "plan")
+        return {
+            type: "plan",
+            text: typeof item.text === "string" ? item.text : "",
+            steps: [],
+        };
+    if (type === "commandExecution")
+        return {
+            type: "command",
+            command: typeof item.command === "string" ? item.command : "",
+            cwd: stringOrNull(item.cwd),
+            output: stringOrNull(item.aggregatedOutput) ?? "",
+            exitCode: typeof item.exitCode === "number" ? item.exitCode : null,
+        };
+    if (type === "fileChange")
+        return {
+            type: "file_change",
+            changes: codexFileChanges(item.changes),
+        };
+    if (type === "mcpToolCall")
+        return {
+            type: "tool",
+            name: stringOrNull(item.tool) ?? "MCP tool",
+            server: stringOrNull(item.server),
+            input: item.arguments ?? null,
+            output: item.result ?? null,
+            error: stringOrNull(record(item.error)?.message),
+            progress: null,
+        };
+    if (type === "functionCallOutput")
+        return {
+            type: "tool",
+            name: stringOrNull(item.name) ?? "Tool",
+            server: stringOrNull(item.namespace),
+            input: null,
+            output: item.output ?? null,
+            error: null,
+            progress: null,
+        };
+    if (type === "dynamicToolCall")
+        return {
+            type: "tool",
+            progress: null,
+            name: typeof item.tool === "string" ? item.tool : "Tool",
+            server: stringOrNull(item.namespace),
+            input: item.arguments ?? null,
+            output: item.contentItems ?? null,
+            error: item.success === false ? "Tool call failed" : null,
+        };
+    if (type === "webSearch")
+        return {
+            type: "tool",
+            progress: null,
+            name: "web_search",
+            server: null,
+            input: null,
+            output: item,
+            error: null,
+        };
+    if (type === "imageView" && typeof item.path === "string")
+        return artifactFromPath(item.path, workspaceRoot);
+    if (type === "imageGeneration") {
+        if (typeof item.savedPath === "string")
+            return generatedArtifactFromPath(item.savedPath, workspaceRoot);
+        return {
+            type: "notice",
+            level: item.failure ? "error" : "info",
+            text: item.failure
+                ? (stringifyOptional(item.failure) ?? "Image generation failed")
+                : "Generating image…",
+        };
+    }
+    return null;
+}
+function generatedArtifactFromPath(value, workspaceRoot) {
+    const existing = artifactFromPath(value, workspaceRoot);
+    if (existing.type === "artifact")
+        return existing;
+    const source = path.resolve(value);
+    const mime = imageMime(source);
+    if (!mime || !existsSync(source) || !statSync(source).isFile())
+        return existing;
+    return {
+        type: "artifact",
+        artifact: {
+            kind: "image",
+            name: path.basename(source),
+            path: source,
+            mimeType: mime,
+        },
+    };
+}
+function artifactFromPath(value, workspaceRoot) {
+    const absolute = path.isAbsolute(value)
+        ? path.resolve(value)
+        : path.resolve(workspaceRoot, value);
+    const relative = path.relative(workspaceRoot, absolute);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        return {
+            type: "notice",
+            level: "warning",
+            text: "Agent produced an artifact outside the workspace: " + value,
+        };
+    }
+    const safePath = relative.split(path.sep).join("/");
+    return {
+        type: "artifact",
+        artifact: {
+            kind: imageMime(safePath) ? "image" : "file",
+            name: path.basename(safePath),
+            path: safePath,
+            mimeType: imageMime(safePath),
+        },
+    };
+}
+export function codexFileChanges(value) {
+    return array(value)
+        .map(record)
+        .filter((change) => Boolean(change))
+        .map((change) => {
+        const kind = record(change.kind);
+        const type = kind?.type === "add" ||
+            kind?.type === "delete" ||
+            kind?.type === "update"
+            ? kind.type
+            : "update";
+        return {
+            path: typeof change.path === "string" ? change.path : "",
+            kind: type,
+            movePath: type === "update" && typeof kind?.move_path === "string"
+                ? kind.move_path
+                : null,
+            diff: typeof change.diff === "string" ? change.diff : "",
+        };
+    });
+}
+export function codexItemFailed(item) {
+    if (item.type === "commandExecution")
+        return typeof item.exitCode === "number" && item.exitCode !== 0;
+    if (item.type === "dynamicToolCall")
+        return item.success === false;
+    if (item.type === "mcpToolCall")
+        return item.status === "failed" || Boolean(item.error);
+    if (item.type === "imageGeneration")
+        return Boolean(item.failure);
+    return false;
+}
+export function grantedPermissions(requested) {
+    const output = {};
+    const network = record(requested.network);
+    const fileSystem = record(requested.fileSystem);
+    if (network)
+        output.network = network;
+    if (fileSystem)
+        output.fileSystem = fileSystem;
+    return output;
+}
+export function codexQuestions(value) {
+    return array(value)
+        .map(record)
+        .filter((question) => Boolean(question))
+        .map((question, index) => {
+        const id = typeof question.id === "string" ? question.id : "question_" + index;
+        const options = questionOptions(question.options);
+        return {
+            id,
+            label: typeof question.header === "string" ? question.header : id,
+            question: typeof question.question === "string"
+                ? question.question
+                : "Provide input",
+            options,
+            multiSelect: Boolean(question.isMultiSelect ?? question.multiSelect),
+            allowFreeText: Boolean(question.isOther) || options.length === 0,
+            secret: Boolean(question.isSecret),
+        };
+    });
+}
+function resolveAttachmentPath(root, attachmentPath) {
+    const absolute = path.resolve(root, attachmentPath);
+    const relative = path.relative(root, absolute);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        throw new Error("Attachment is outside the workspace");
+    return absolute;
+}
+function imageMime(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".avif":
+            return "image/avif";
+        default:
+            return null;
+    }
+}
+export function stringOrNull(value) {
+    return typeof value === "string" ? value : null;
+}
+export function codexVersion(userAgent) {
+    const match = userAgent.match(/\b(\d+\.\d+\.\d+)\b/);
+    return match?.[1] ?? null;
+}
+export async function injectWorkspacePrompt(client, threadId, prompt) {
+    if (!prompt)
+        return;
+    await client.request("thread/inject_items", {
+        threadId,
+        items: [
+            {
+                type: "message",
+                role: "developer",
+                content: [
+                    {
+                        type: "input_text",
+                        text: workspaceInstructions(prompt),
+                    },
+                ],
+            },
+        ],
+    });
+}
+export async function injectContinuity(client, threadId, context) {
+    if (!context)
+        return;
+    await client.request("thread/inject_items", {
+        threadId,
+        items: [
+            {
+                type: "message",
+                role: "developer",
+                content: [
+                    {
+                        type: "input_text",
+                        text: continuityInstructions(context),
+                    },
+                ],
+            },
+        ],
+    });
+}
+export function sessionConfig(context) {
+    return {
+        model: context.model,
+        reasoningEffort: context.reasoningEffort,
+        reasoningSummary: context.reasoningSummary,
+        serviceTier: context.serviceTier,
+        approvalPolicy: context.approvalPolicy,
+        approvalsReviewer: context.approvalsReviewer,
+        permissionMode: context.permissionMode,
+    };
+}
+export function standardApprovalChoices() {
+    return [
+        { id: "accept", label: "Allow", description: null },
+        {
+            id: "acceptForSession",
+            label: "Allow for this session",
+            description: null,
+        },
+        { id: "decline", label: "Deny", description: null },
+        { id: "cancel", label: "Cancel turn", description: null },
+    ].map((choice) => ({ ...choice, result: { decision: choice.id } }));
+}
+export function turnError(value) {
+    const error = record(value);
+    if (!error || typeof error.message !== "string")
+        return null;
+    const errorInfo = error.codexErrorInfo ?? null;
+    const misalignment = error.misalignment ?? null;
+    return {
+        message: error.message,
+        details: stringOrNull(error.additionalDetails),
+        providerData: errorInfo !== null || misalignment !== null
+            ? { errorInfo, misalignment }
+            : null,
+    };
+}
+export function codexAccountUsage(value) {
+    const response = record(value);
+    const limits = record(response?.rateLimits);
+    if (!limits)
+        return null;
+    const windows = [];
+    const addWindow = (id, raw) => {
+        const window = record(raw);
+        if (!window)
+            return;
+        const duration = typeof window.windowDurationMins === "number"
+            ? window.windowDurationMins
+            : null;
+        const resetSeconds = typeof window.resetsAt === "number" ? window.resetsAt : null;
+        windows.push({
+            id,
+            label: duration === 300 || duration === 10080 || duration === null
+                ? null
+                : formatCodexWindow(duration),
+            utilization: typeof window.usedPercent === "number" ? window.usedPercent : null,
+            resetsAt: resetSeconds === null
+                ? null
+                : new Date(resetSeconds * 1000).toISOString(),
+        });
+    };
+    addWindow("five_hour", limits.primary);
+    addWindow("seven_day", limits.secondary);
+    return {
+        subscriptionType: typeof limits.planType === "string" ? limits.planType : null,
+        windows,
+        extraUsage: null,
+        updatedAt: new Date().toISOString(),
+    };
+}
+function formatCodexWindow(minutes) {
+    if (minutes % 1440 === 0)
+        return minutes / 1440 + " days";
+    if (minutes % 60 === 0)
+        return minutes / 60 + " hours";
+    return minutes + " minutes";
+}
+export function tokenUsage(value) {
+    const usage = record(value);
+    if (!usage)
+        return null;
+    const breakdown = (value) => {
+        const entry = record(value);
+        if (!entry)
+            return null;
+        const { totalTokens, inputTokens, cachedInputTokens, cacheWriteInputTokens, outputTokens, reasoningOutputTokens, } = entry;
+        if (typeof totalTokens !== "number" ||
+            typeof inputTokens !== "number" ||
+            typeof cachedInputTokens !== "number" ||
+            typeof cacheWriteInputTokens !== "number" ||
+            typeof outputTokens !== "number" ||
+            typeof reasoningOutputTokens !== "number")
+            return null;
+        return {
+            totalTokens,
+            inputTokens,
+            cachedInputTokens,
+            cacheWriteInputTokens,
+            outputTokens,
+            reasoningOutputTokens,
+        };
+    };
+    const total = breakdown(usage.total);
+    const last = breakdown(usage.last);
+    if (!total ||
+        !last ||
+        (usage.modelContextWindow !== null &&
+            typeof usage.modelContextWindow !== "number"))
+        return null;
+    return { total, last, modelContextWindow: usage.modelContextWindow };
+}
+export function codexInput(input, workspaceRoot) {
+    return [
+        { type: "text", text: input.text, text_elements: [] },
+        ...input.attachments.map((attachment) => {
+            const resolved = resolveAttachmentPath(workspaceRoot, attachment.path);
+            if (attachment.kind === "image" || attachment.kind === "audio")
+                return {
+                    type: attachment.kind === "image" ? "localImage" : "localAudio",
+                    path: resolved,
+                };
+            return {
+                type: attachment.kind === "skill" ? "skill" : "mention",
+                name: attachment.name,
+                path: resolved,
+            };
+        }),
+    ];
+}
+export function reviewTarget(target) {
+    switch (target.type) {
+        case "uncommittedChanges":
+            return { type: target.type };
+        case "baseBranch":
+            return { type: target.type, branch: target.branch };
+        case "commit":
+            return {
+                type: target.type,
+                sha: target.sha,
+                title: target.title ?? null,
+            };
+        case "custom":
+            return { type: target.type, instructions: target.instructions };
+        default:
+            throw new Error("Unsupported Codex review target");
+    }
+}
+export function codexWarning(method, params) {
+    if (method === "warning")
+        return stringOrNull(params.message);
+    if (method === "configWarning" || method === "deprecationNotice") {
+        const summary = stringOrNull(params.summary);
+        return summary === null
+            ? null
+            : [summary, stringOrNull(params.details)].filter(Boolean).join("\n");
+    }
+    return null;
+}

package/dist/plugins/agent/providers/codex/provider.d.ts

@@ -0,0 +1,84 @@
+import type { LogWriter } from "#core/logging/types";
+import type { AgentProvider, AgentProviderContext, ProviderSession } from "#plugins/agent/provider";
+import type { AgentModel, AgentProviderProbe, AgentProviderDetails } from "#plugins/agent/types";
+export declare class CodexProvider implements AgentProvider {
+    private readonly logs;
+    readonly id = "codex";
+    readonly displayName = "Codex";
+    readonly icon = "openai";
+    readonly features: {
+        readonly nativeReview: true;
+        readonly steering: true;
+    };
+    readonly nativeSettings: readonly [{
+        readonly id: "approvalPolicy";
+        readonly defaultValue: "on-request";
+        readonly options: readonly [{
+            readonly id: "untrusted";
+            readonly description: "Ask for approval before running commands outside the trusted set.";
+        }, {
+            readonly id: "on-request";
+            readonly description: "Let Codex request approval when it decides escalation is needed.";
+        }, {
+            readonly id: "granular";
+            readonly description: "Control individual Codex approval categories.";
+        }, {
+            readonly id: "never";
+            readonly description: "Never ask for approval; disallowed operations fail instead.";
+        }];
+        readonly granularFields: readonly [{
+            readonly id: "sandbox_approval";
+            readonly description: "Sandbox approval requests.";
+        }, {
+            readonly id: "rules";
+            readonly description: "Rule-based approval requests.";
+        }, {
+            readonly id: "skill_approval";
+            readonly description: "Skill approval requests.";
+        }, {
+            readonly id: "request_permissions";
+            readonly description: "Additional permission requests.";
+        }, {
+            readonly id: "mcp_elicitations";
+            readonly description: "MCP elicitation requests.";
+        }];
+    }, {
+        readonly id: "permissionMode";
+        readonly defaultValue: "workspace-write";
+        readonly options: readonly [{
+            readonly id: "read-only";
+            readonly description: "Read-only sandbox; changes require approval.";
+        }, {
+            readonly id: "workspace-write";
+            readonly description: "Allow workspace writes within the sandbox.";
+        }, {
+            readonly id: "danger-full-access";
+            readonly description: "Disable the sandbox; commands can access files and the network outside the workspace.";
+        }];
+        readonly granularFields: readonly [];
+    }, {
+        readonly id: "approvalsReviewer";
+        readonly defaultValue: "user";
+        readonly options: readonly [{
+            readonly id: "user";
+            readonly description: "Route approval requests to the user.";
+        }, {
+            readonly id: "auto_review";
+            readonly description: "Use Codex auto review to approve or deny requests with a risk-based subagent.";
+        }, {
+            readonly id: "guardian_subagent";
+            readonly description: "Route approval requests to the Codex guardian subagent.";
+        }];
+        readonly granularFields: readonly [];
+    }];
+    private readonly client;
+    private readonly modelNames;
+    constructor(logs: LogWriter);
+    probe(): Promise<AgentProviderProbe>;
+    details(): Promise<AgentProviderDetails>;
+    listModels(): Promise<AgentModel[]>;
+    createSession(context: AgentProviderContext): Promise<ProviderSession>;
+    resumeSession(context: AgentProviderContext, providerSessionId: string): Promise<ProviderSession>;
+    private resolveModel;
+    close(): Promise<void>;
+}