@xfey/tutti 0.1.0

package/dist/providers/openai/app-server/skills.d.ts

@@ -0,0 +1,82 @@
+export type CodexAppServerSkillInput = {
+    name: string;
+    path: string;
+};
+export type CodexAppServerTextInputItem = {
+    type: "text";
+    text: string;
+    text_elements: [];
+};
+export type CodexAppServerSkillInputItem = {
+    type: "skill";
+    name: string;
+    path: string;
+};
+export type CodexAppServerTurnInputItem = CodexAppServerSkillInputItem | CodexAppServerTextInputItem;
+export type CodexAppServerBuiltInSkillName = "read-main-chat" | "read-project-docs" | "read-scratchpad" | "read-worklist" | "read-references" | "read-user-skills";
+export type CodexAppServerSkillSelectionName = "chat_assistant" | "project_context_bootstrap" | "task_compile" | "context_sync" | "reference_summary_refresh" | "workspace_write_run" | "follow_up_run";
+export type CodexAppServerContextApiScope = "messages:read" | "project-docs:list" | "project-docs:read" | "scratchpad:read" | "worklist:read" | "task:read" | "references:list" | "references:read" | "skills:list" | "skills:read";
+export type CodexAppServerSkillSelection = {
+    builtInSkillNames: CodexAppServerBuiltInSkillName[];
+    userSkillMode: "disabled" | "all_enabled";
+    contextApiScopes: CodexAppServerContextApiScope[];
+};
+export type CodexAppServerAgentContextTokenRequest = {
+    selectionName: CodexAppServerSkillSelectionName;
+    scopes: CodexAppServerContextApiScope[];
+};
+export type CodexAppServerAgentContextToken = {
+    token: string;
+    expires_at?: string;
+};
+export type CodexAppServerAgentContextRuntime = {
+    baseUrl: string;
+    issueToken: (input: CodexAppServerAgentContextTokenRequest) => CodexAppServerAgentContextToken;
+};
+export type CodexAppServerSkillsListWarmup = {
+    cwds: string[];
+    forceReload: true;
+    perCwdExtraUserRoots: Array<{
+        cwd: string;
+        extraUserRoots: string[];
+    }>;
+};
+export type CodexAppServerContextRuntimeHint = {
+    text: string;
+    sensitiveValues: string[];
+    scopes: CodexAppServerContextApiScope[];
+};
+export declare class CodexAppServerSkillSelectionError extends Error {
+    readonly code: "built_in_skill_not_found" | "built_in_skill_invalid";
+    constructor(code: "built_in_skill_not_found" | "built_in_skill_invalid", message: string);
+}
+export declare const CODEX_APP_SERVER_SKILL_SELECTIONS: Record<CodexAppServerSkillSelectionName, CodexAppServerSkillSelection>;
+export declare function resolveCodexAppServerSkillSelection(selectionName: CodexAppServerSkillSelectionName): CodexAppServerSkillSelection;
+export declare function resolveCodexAppServerSkillInputs(options: {
+    selectionName?: CodexAppServerSkillSelectionName;
+    selection?: CodexAppServerSkillSelection;
+    builtInSkillsRoot?: string;
+    tuttiHome?: string;
+}): CodexAppServerSkillInput[];
+export declare function resolveCodexAppServerSkillsListWarmup(options: {
+    cwd: string;
+    selectionName?: CodexAppServerSkillSelectionName;
+    selection?: CodexAppServerSkillSelection;
+    tuttiHome?: string;
+}): CodexAppServerSkillsListWarmup | undefined;
+export declare function buildCodexAppServerTurnInput(options: {
+    prompt: string;
+    skills?: CodexAppServerSkillInput[];
+    runtimeHints?: string[];
+}): CodexAppServerTurnInputItem[];
+export declare function buildCodexAppServerContextRuntimeHint(options: {
+    baseUrl: string;
+    token: string;
+    scopes: CodexAppServerContextApiScope[];
+    expiresAt?: string;
+}): string;
+export declare function resolveCodexAppServerContextRuntimeHint(options: {
+    selectionName?: CodexAppServerSkillSelectionName;
+    agentContext?: CodexAppServerAgentContextRuntime;
+}): CodexAppServerContextRuntimeHint | undefined;
+//# sourceMappingURL=skills.d.ts.map

package/dist/providers/openai/app-server/skills.js

@@ -0,0 +1,222 @@
+import { existsSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getUserSkillsRoot, listUserSkills } from "../../../skills/index.js";
+export class CodexAppServerSkillSelectionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CodexAppServerSkillSelectionError";
+    }
+}
+export const CODEX_APP_SERVER_SKILL_SELECTIONS = {
+    chat_assistant: {
+        builtInSkillNames: [
+            "read-main-chat",
+            "read-project-docs",
+            "read-scratchpad",
+            "read-worklist",
+            "read-references",
+            "read-user-skills",
+        ],
+        userSkillMode: "disabled",
+        contextApiScopes: [
+            "messages:read",
+            "project-docs:list",
+            "project-docs:read",
+            "scratchpad:read",
+            "worklist:read",
+            "task:read",
+            "references:list",
+            "references:read",
+            "skills:list",
+            "skills:read",
+        ],
+    },
+    project_context_bootstrap: {
+        builtInSkillNames: ["read-project-docs", "read-references"],
+        userSkillMode: "disabled",
+        contextApiScopes: [
+            "project-docs:list",
+            "project-docs:read",
+            "references:list",
+            "references:read",
+        ],
+    },
+    task_compile: {
+        builtInSkillNames: ["read-project-docs", "read-worklist", "read-references"],
+        userSkillMode: "disabled",
+        contextApiScopes: [
+            "project-docs:list",
+            "project-docs:read",
+            "worklist:read",
+            "task:read",
+            "references:list",
+            "references:read",
+        ],
+    },
+    context_sync: {
+        builtInSkillNames: ["read-project-docs", "read-worklist", "read-references"],
+        userSkillMode: "disabled",
+        contextApiScopes: [
+            "project-docs:list",
+            "project-docs:read",
+            "worklist:read",
+            "task:read",
+            "references:list",
+            "references:read",
+        ],
+    },
+    reference_summary_refresh: {
+        builtInSkillNames: [],
+        userSkillMode: "disabled",
+        contextApiScopes: [],
+    },
+    workspace_write_run: {
+        builtInSkillNames: ["read-project-docs", "read-worklist"],
+        userSkillMode: "all_enabled",
+        contextApiScopes: [
+            "project-docs:list",
+            "project-docs:read",
+            "worklist:read",
+            "task:read",
+        ],
+    },
+    follow_up_run: {
+        builtInSkillNames: ["read-project-docs", "read-worklist"],
+        userSkillMode: "all_enabled",
+        contextApiScopes: [
+            "project-docs:list",
+            "project-docs:read",
+            "worklist:read",
+            "task:read",
+        ],
+    },
+};
+const DEFAULT_BUILT_IN_SKILLS_ROOT = fileURLToPath(new URL("../../../../prompts/skills", import.meta.url));
+function assertInside(parent, child) {
+    const parentPath = resolve(parent);
+    const childPath = resolve(child);
+    if (childPath !== parentPath && !childPath.startsWith(`${parentPath}/`)) {
+        throw new CodexAppServerSkillSelectionError("built_in_skill_invalid", "Built-in skill path escapes skill root.");
+    }
+}
+function resolveBuiltInSkill(options) {
+    const path = join(options.builtInSkillsRoot, options.name);
+    assertInside(options.builtInSkillsRoot, path);
+    const skillMdPath = join(path, "SKILL.md");
+    if (!existsSync(skillMdPath)) {
+        throw new CodexAppServerSkillSelectionError("built_in_skill_not_found", `Built-in skill is missing: ${options.name}`);
+    }
+    if (!statSync(skillMdPath).isFile()) {
+        throw new CodexAppServerSkillSelectionError("built_in_skill_invalid", `Built-in skill is invalid: ${options.name}`);
+    }
+    return { name: options.name, path };
+}
+function resolveUserSkill(options) {
+    return {
+        name: options.name,
+        path: join(getUserSkillsRoot(options.tuttiHome), options.name),
+    };
+}
+export function resolveCodexAppServerSkillSelection(selectionName) {
+    return CODEX_APP_SERVER_SKILL_SELECTIONS[selectionName];
+}
+export function resolveCodexAppServerSkillInputs(options) {
+    const selection = options.selection ??
+        (options.selectionName === undefined
+            ? {
+                builtInSkillNames: [],
+                userSkillMode: "disabled",
+                contextApiScopes: [],
+            }
+            : resolveCodexAppServerSkillSelection(options.selectionName));
+    const builtInSkillsRoot = options.builtInSkillsRoot ?? DEFAULT_BUILT_IN_SKILLS_ROOT;
+    const builtInSkills = selection.builtInSkillNames.map((name) => resolveBuiltInSkill({ builtInSkillsRoot, name }));
+    const userSkills = selection.userSkillMode === "all_enabled" && options.tuttiHome !== undefined
+        ? listUserSkills(options.tuttiHome).map((skill) => resolveUserSkill({ tuttiHome: options.tuttiHome, name: skill.name }))
+        : [];
+    return [...builtInSkills, ...userSkills];
+}
+export function resolveCodexAppServerSkillsListWarmup(options) {
+    const selection = options.selection ??
+        (options.selectionName === undefined
+            ? {
+                builtInSkillNames: [],
+                userSkillMode: "disabled",
+                contextApiScopes: [],
+            }
+            : resolveCodexAppServerSkillSelection(options.selectionName));
+    if (selection.userSkillMode !== "all_enabled" || options.tuttiHome === undefined) {
+        return undefined;
+    }
+    if (listUserSkills(options.tuttiHome).length === 0) {
+        return undefined;
+    }
+    return {
+        cwds: [options.cwd],
+        forceReload: true,
+        perCwdExtraUserRoots: [
+            {
+                cwd: options.cwd,
+                extraUserRoots: [getUserSkillsRoot(options.tuttiHome)],
+            },
+        ],
+    };
+}
+function createTextInputItem(text) {
+    return {
+        type: "text",
+        text,
+        text_elements: [],
+    };
+}
+export function buildCodexAppServerTurnInput(options) {
+    return [
+        ...(options.skills ?? []).map((skill) => ({
+            type: "skill",
+            name: skill.name,
+            path: skill.path,
+        })),
+        ...(options.runtimeHints ?? [])
+            .filter((hint) => hint.trim().length > 0)
+            .map((hint) => createTextInputItem(hint)),
+        createTextInputItem(options.prompt),
+    ];
+}
+export function buildCodexAppServerContextRuntimeHint(options) {
+    return [
+        "Tutti context API is available for this turn.",
+        `Base URL: ${options.baseUrl.replace(/\/+$/u, "")}`,
+        `Authorization: Bearer ${options.token}`,
+        `Allowed scopes: ${options.scopes.join(", ")}`,
+        ...(options.expiresAt === undefined ? [] : [`Token expires at: ${options.expiresAt}`]),
+        "Use these read-only endpoints only when additional Tutti collaboration context is needed.",
+        "Do not include the token, base URL, or raw large API responses in user-facing output.",
+    ].join("\n");
+}
+export function resolveCodexAppServerContextRuntimeHint(options) {
+    if (options.selectionName === undefined || options.agentContext === undefined) {
+        return undefined;
+    }
+    const selection = resolveCodexAppServerSkillSelection(options.selectionName);
+    if (selection.contextApiScopes.length === 0) {
+        return undefined;
+    }
+    const issued = options.agentContext.issueToken({
+        selectionName: options.selectionName,
+        scopes: selection.contextApiScopes,
+    });
+    return {
+        text: buildCodexAppServerContextRuntimeHint({
+            baseUrl: options.agentContext.baseUrl,
+            token: issued.token,
+            scopes: selection.contextApiScopes,
+            ...(issued.expires_at === undefined ? {} : { expiresAt: issued.expires_at }),
+        }),
+        sensitiveValues: [issued.token, options.agentContext.baseUrl],
+        scopes: selection.contextApiScopes,
+    };
+}
+//# sourceMappingURL=skills.js.map

package/dist/providers/openai/app-server/smoke-cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=smoke-cli.d.ts.map

package/dist/providers/openai/app-server/smoke-cli.js

@@ -0,0 +1,42 @@
+import { CodexAppServerSmokeError, resolveCodexAppServerSmokeProviderInput, runCodexAppServerNoWriteSmoke, } from "./smoke.js";
+function readBooleanFlag(flag) {
+    return process.argv.includes(flag);
+}
+async function main() {
+    const providerInput = resolveCodexAppServerSmokeProviderInput();
+    const smokeOptions = {
+        apiKey: providerInput.apiKey,
+        keepTemp: readBooleanFlag("--keep-temp"),
+        strictLeakCheck: readBooleanFlag("--strict-leak-check"),
+    };
+    if (providerInput.apiBaseUrl !== undefined) {
+        smokeOptions.apiBaseUrl = providerInput.apiBaseUrl;
+    }
+    if (providerInput.defaultModel !== undefined) {
+        smokeOptions.defaultModel = providerInput.defaultModel;
+    }
+    const result = await runCodexAppServerNoWriteSmoke(smokeOptions);
+    console.log(JSON.stringify({
+        provider_source: providerInput.source,
+        ...result,
+    }, null, 2));
+}
+main().catch((error) => {
+    if (error instanceof CodexAppServerSmokeError) {
+        console.error(JSON.stringify({
+            status: "failed",
+            code: error.code,
+            message: error.message,
+        }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(JSON.stringify({
+        status: "failed",
+        code: "unexpected_error",
+        message,
+    }, null, 2));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=smoke-cli.js.map

package/dist/providers/openai/app-server/smoke-helpers.d.ts

@@ -0,0 +1,19 @@
+import type { CodexAppServerJsonRpcNotification, CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+export declare function renderNoWriteSmokePrompt(): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isApiKeyAccount(value: unknown): value is {
+    type: "apiKey";
+};
+export declare function readAccountType(value: unknown): "apiKey" | null;
+export declare function readThreadId(value: unknown): string | null;
+export declare function readTurnStatus(value: unknown): string | null;
+export declare function extractNotificationMethod(value: CodexAppServerJsonRpcServerRequest): string;
+export declare function extractAgentText(notification: CodexAppServerJsonRpcNotification): string;
+export declare function redactWithKnownValues(value: string, sensitiveValues: readonly string[]): string;
+export declare function containsKnownSecret(value: string, secrets: readonly string[]): boolean;
+export declare function createSmokeRepo(root: string): string;
+export declare function readGitStatus(repoRoot: string): string;
+export declare function createCodexSpawnEnv(codexHome: string, baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function countAvailableModels(modelListResponse: unknown): number;
+export declare function modelListContains(modelListResponse: unknown, model: string): boolean;
+//# sourceMappingURL=smoke-helpers.d.ts.map

package/dist/providers/openai/app-server/smoke-helpers.js

@@ -0,0 +1,125 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { REDACTION_LABELS, redactText } from "@tutti/shared/utils";
+import { renderPromptTemplate } from "../../../prompt-templates/index.js";
+import { SMOKE_SENTINEL } from "./smoke-types.js";
+export function renderNoWriteSmokePrompt() {
+    return renderPromptTemplate({
+        templateKey: "codex.no_write_smoke",
+        variables: {
+            smoke_sentinel: SMOKE_SENTINEL,
+        },
+    });
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isApiKeyAccount(value) {
+    return isRecord(value) && value.type === "apiKey";
+}
+export function readAccountType(value) {
+    if (!isRecord(value) || !isRecord(value.account)) {
+        return null;
+    }
+    return value.account.type === "apiKey" ? "apiKey" : null;
+}
+export function readThreadId(value) {
+    if (!isRecord(value) || !isRecord(value.thread) || typeof value.thread.id !== "string") {
+        return null;
+    }
+    return value.thread.id;
+}
+export function readTurnStatus(value) {
+    if (!isRecord(value) || !isRecord(value.turn) || typeof value.turn.status !== "string") {
+        return null;
+    }
+    return value.turn.status;
+}
+export function extractNotificationMethod(value) {
+    return value.method;
+}
+export function extractAgentText(notification) {
+    if (!isRecord(notification.params)) {
+        return "";
+    }
+    if (notification.method === "item/agentMessage/delta" &&
+        typeof notification.params.delta === "string") {
+        return notification.params.delta;
+    }
+    if (notification.method === "item/completed" &&
+        isRecord(notification.params.item) &&
+        notification.params.item.type === "agentMessage" &&
+        typeof notification.params.item.text === "string") {
+        return notification.params.item.text;
+    }
+    return "";
+}
+export function redactWithKnownValues(value, sensitiveValues) {
+    let redacted = redactText(value);
+    const orderedSensitiveValues = [...sensitiveValues]
+        .filter((sensitiveValue) => sensitiveValue !== "")
+        .sort((left, right) => right.length - left.length);
+    for (const sensitiveValue of orderedSensitiveValues) {
+        redacted = redacted
+            .split(sensitiveValue)
+            .join(isAbsolute(sensitiveValue) ? REDACTION_LABELS.localPath : "[REDACTED]");
+    }
+    return redacted;
+}
+export function containsKnownSecret(value, secrets) {
+    return secrets.some((secret) => secret !== "" && value.includes(secret));
+}
+export function createSmokeRepo(root) {
+    const repoRoot = join(root, "repo");
+    mkdirSync(repoRoot, { recursive: true, mode: 0o700 });
+    writeFileSync(join(repoRoot, "README.md"), `${SMOKE_SENTINEL}\n`, { mode: 0o600 });
+    execFileSync("git", ["init"], { cwd: repoRoot, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "tutti-smoke@example.invalid"], {
+        cwd: repoRoot,
+        stdio: "ignore",
+    });
+    execFileSync("git", ["config", "user.name", "Tutti Smoke"], {
+        cwd: repoRoot,
+        stdio: "ignore",
+    });
+    execFileSync("git", ["add", "README.md"], { cwd: repoRoot, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "smoke baseline"], { cwd: repoRoot, stdio: "ignore" });
+    return repoRoot;
+}
+export function readGitStatus(repoRoot) {
+    return execFileSync("git", ["status", "--porcelain", "--untracked-files=all"], {
+        cwd: repoRoot,
+        encoding: "utf8",
+    });
+}
+export function createCodexSpawnEnv(codexHome, baseEnv) {
+    const env = {
+        CODEX_HOME: codexHome,
+    };
+    if (baseEnv.PATH !== undefined) {
+        env.PATH = baseEnv.PATH;
+    }
+    if (baseEnv.HOME !== undefined) {
+        env.HOME = baseEnv.HOME;
+    }
+    return env;
+}
+export function countAvailableModels(modelListResponse) {
+    if (!isRecord(modelListResponse) || !Array.isArray(modelListResponse.data)) {
+        return 0;
+    }
+    return modelListResponse.data.length;
+}
+export function modelListContains(modelListResponse, model) {
+    if (!isRecord(modelListResponse) || !Array.isArray(modelListResponse.data)) {
+        return false;
+    }
+    return modelListResponse.data.some((item) => {
+        if (!isRecord(item)) {
+            return false;
+        }
+        return item.id === model || item.name === model;
+    });
+}
+//# sourceMappingURL=smoke-helpers.js.map

package/dist/providers/openai/app-server/smoke-provider-input.d.ts

@@ -0,0 +1,6 @@
+import { type ResolvedCodexAppServerSmokeProviderInput } from "./smoke-types.js";
+export declare function resolveCodexAppServerSmokeProviderInput(options?: {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): ResolvedCodexAppServerSmokeProviderInput;
+//# sourceMappingURL=smoke-provider-input.d.ts.map

package/dist/providers/openai/app-server/smoke-provider-input.js

@@ -0,0 +1,20 @@
+import { CodexAppServerSmokeError, } from "./smoke-types.js";
+export function resolveCodexAppServerSmokeProviderInput(options = {}) {
+    const env = options.env ?? process.env;
+    const envApiKey = env.TUTTI_API_KEY;
+    if (envApiKey !== undefined && envApiKey.trim() !== "") {
+        const input = {
+            source: "env",
+            apiKey: envApiKey,
+        };
+        if (env.TUTTI_BASE_URL !== undefined && env.TUTTI_BASE_URL.trim() !== "") {
+            input.apiBaseUrl = env.TUTTI_BASE_URL;
+        }
+        if (env.TUTTI_MODEL !== undefined && env.TUTTI_MODEL.trim() !== "") {
+            input.defaultModel = env.TUTTI_MODEL;
+        }
+        return input;
+    }
+    throw new CodexAppServerSmokeError("missing_provider_credential", "Set TUTTI_API_KEY for the live app-server smoke.");
+}
+//# sourceMappingURL=smoke-provider-input.js.map

package/dist/providers/openai/app-server/smoke-types.d.ts

@@ -0,0 +1,49 @@
+export declare const SMOKE_SENTINEL = "TUTTI_SMOKE_SENTINEL_20260519";
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
+export declare const DEFAULT_TURN_TIMEOUT_MS = 180000;
+export declare const CODEX_APP_SERVER_READ_ONLY_SMOKE_OUTPUT_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["sentinel"];
+    readonly properties: {
+        readonly sentinel: {
+            readonly type: "string";
+        };
+    };
+};
+export type CodexAppServerSmokeProviderInput = {
+    apiKey: string;
+    apiBaseUrl?: string;
+    defaultModel?: string;
+};
+export type CodexAppServerSmokeInputSource = "env";
+export type ResolvedCodexAppServerSmokeProviderInput = CodexAppServerSmokeProviderInput & {
+    source: CodexAppServerSmokeInputSource;
+};
+export type CodexAppServerNoWriteSmokeOptions = CodexAppServerSmokeProviderInput & {
+    codexCommand?: string;
+    keepTemp?: boolean;
+    strictLeakCheck?: boolean;
+    requestTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    baseEnv?: NodeJS.ProcessEnv;
+};
+export type CodexAppServerNoWriteSmokeResult = {
+    status: "passed";
+    model: string;
+    account_type: "apiKey";
+    model_count: number;
+    default_model_available: boolean;
+    turn_status: "completed";
+    notification_count: number;
+    agent_message_event_count: number;
+    server_request_methods: string[];
+    git_status_clean: true;
+    stderr_had_output: boolean;
+    stderr_excerpt: string;
+};
+export declare class CodexAppServerSmokeError extends Error {
+    readonly code: "missing_provider_credential" | "credential_unavailable" | "app_server_protocol_error" | "auth_failed" | "model_unavailable" | "thread_start_failed" | "turn_failed" | "unexpected_server_request" | "sentinel_missing" | "write_detected" | "secret_leak_detected";
+    constructor(code: "missing_provider_credential" | "credential_unavailable" | "app_server_protocol_error" | "auth_failed" | "model_unavailable" | "thread_start_failed" | "turn_failed" | "unexpected_server_request" | "sentinel_missing" | "write_detected" | "secret_leak_detected", message: string);
+}
+//# sourceMappingURL=smoke-types.d.ts.map

package/dist/providers/openai/app-server/smoke-types.js

@@ -0,0 +1,20 @@
+export const SMOKE_SENTINEL = "TUTTI_SMOKE_SENTINEL_20260519";
+export const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+export const DEFAULT_TURN_TIMEOUT_MS = 180_000;
+export const CODEX_APP_SERVER_READ_ONLY_SMOKE_OUTPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["sentinel"],
+    properties: {
+        sentinel: { type: "string" },
+    },
+};
+export class CodexAppServerSmokeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CodexAppServerSmokeError";
+    }
+}
+//# sourceMappingURL=smoke-types.js.map

package/dist/providers/openai/app-server/smoke.d.ts

@@ -0,0 +1,9 @@
+import { CODEX_APP_SERVER_COMMAND, CODEX_APP_SERVER_LISTEN_URL } from "../codex-app-server.js";
+import { resolveCodexAppServerSmokeProviderInput } from "./smoke-provider-input.js";
+import { type CodexAppServerNoWriteSmokeOptions, type CodexAppServerNoWriteSmokeResult } from "./smoke-types.js";
+export { CODEX_APP_SERVER_COMMAND, CODEX_APP_SERVER_LISTEN_URL };
+export { resolveCodexAppServerSmokeProviderInput };
+export { CodexAppServerSmokeError, SMOKE_SENTINEL, } from "./smoke-types.js";
+export type { CodexAppServerNoWriteSmokeOptions, CodexAppServerNoWriteSmokeResult, CodexAppServerSmokeInputSource, CodexAppServerSmokeProviderInput, ResolvedCodexAppServerSmokeProviderInput, } from "./smoke-types.js";
+export declare function runCodexAppServerNoWriteSmoke(options: CodexAppServerNoWriteSmokeOptions): Promise<CodexAppServerNoWriteSmokeResult>;
+//# sourceMappingURL=smoke.d.ts.map