@velum-labs/routekit-tool-codex 0.18.6 → 1.0.0

package/dist/driver.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import type { HarnessDriver } from "@velum-labs/routekit-harness-core";
+import { z } from "zod";
 export declare const codexDriverConfigSchema: z.ZodObject<{
     command: z.ZodDefault<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;

package/dist/driver.js

@@ -1,33 +1,11 @@
 import { rmSync } from "node:fs";
-import { z } from "zod";
 import { Codex } from "@openai/codex-sdk";
-import { HarnessError, asHarnessError, buildChildEnv, createCachedHarnessDriver, probeCliVersion, resolveDriverEnv } from "@velum-labs/routekit-harness-core";
-import { registerCleanup } from "@velum-labs/routekit-runtime";
+import { asHarnessError, buildChildEnv, createCachedHarnessDriver, HarnessError, nowIso, probeCliVersion, resolveDriverEnv, resumeStringField, SessionResourceRegistry, SingleFlightTurnController } from "@velum-labs/routekit-harness-core";
+import { ResourceScope } from "@velum-labs/routekit-runtime/lifecycle";
+import { z } from "zod";
 import { createIsolatedCodexHome } from "./launch.js";
 const RESUME_CURSOR_VERSION = 1;
 const DEFAULT_COMMAND = "codex";
-/**
- * Gateway-routed sessions run in an isolated `CODEX_HOME`: the user's own
- * `~/.codex/config.toml` (model, reasoning effort, MCP servers, profiles) must
- * not leak into requests routed through the gateway, and codex must not
- * overwrite the user's real models cache with gateway catalog entries. The
- * home is shared per process (not per instance) because codex thread rollouts
- * live inside it and resume cursors must survive across panel turns, each of
- * which builds a fresh driver instance.
- */
-let sharedIsolatedHome;
-function isolatedCodexHome(env) {
-    if (sharedIsolatedHome === undefined) {
-        const home = createIsolatedCodexHome("routekit-codex-driver-", env);
-        sharedIsolatedHome = home;
-        registerCleanup(() => {
-            rmSync(home, { recursive: true, force: true });
-            if (sharedIsolatedHome === home)
-                sharedIsolatedHome = undefined;
-        });
-    }
-    return sharedIsolatedHome;
-}
 const providerSchema = z.object({
     /** OpenAI-compatible base URL the codex model calls go to (e.g. the gateway). */
     baseUrl: z.string().optional(),
@@ -42,16 +20,11 @@ export const codexDriverConfigSchema = z.object({
     sandboxMode: z
         .enum(["read-only", "workspace-write", "danger-full-access"])
         .default("workspace-write"),
-    approvalPolicy: z
-        .enum(["never", "on-request", "on-failure", "untrusted"])
-        .default("never"),
+    approvalPolicy: z.enum(["never", "on-request", "on-failure", "untrusted"]).default("never"),
     provider: providerSchema.default({}),
     /** Extra credential env var names forwarded into the codex child. */
     credentialEnvNames: z.array(z.string()).default([])
 });
-function nowIso() {
-    return new Date().toISOString();
-}
 function itemTypeFor(item) {
     switch (item.type) {
         case "agent_message":
@@ -133,6 +106,8 @@ class CodexSession {
     #thread;
     #kind = "codex";
     #reasoning;
+    #turns = new SingleFlightTurnController();
+    #stopped = false;
     constructor(thread, resumedThreadId, reasoning) {
         this.#thread = thread;
         // Codex assigns the real thread id on the first turn; until then we track
@@ -144,19 +119,25 @@ class CodexSession {
         return this.#sessionId;
     }
     async *sendTurn(input) {
+        if (this.#stopped)
+            throw new HarnessError("session_closed", "codex session is stopped");
         if (input.reasoning !== undefined &&
             JSON.stringify(input.reasoning) !== JSON.stringify(this.#reasoning)) {
             throw new HarnessError("invalid_config", "Codex SDK reasoning must be selected before the session starts");
         }
+        const turn = this.#turns.start(input.signal);
         const base = { kind: this.#kind, sessionId: this.#sessionId, at: nowIso() };
         let turnId;
         let streamed;
         try {
-            streamed = await this.#thread.runStreamed(input.prompt, {
-                ...(input.signal !== undefined ? { signal: input.signal } : {})
-            });
+            streamed = await this.#thread.runStreamed(input.prompt, { signal: turn.signal });
         }
         catch (error) {
+            turn.dispose();
+            if (turn.signal.aborted) {
+                yield { ...base, type: "turn.completed", endReason: "aborted" };
+                return;
+            }
             throw asHarnessError(error);
         }
         try {
@@ -168,7 +149,7 @@ class CodexSession {
             }
         }
         catch (error) {
-            if (input.signal?.aborted === true) {
+            if (turn.signal.aborted) {
                 yield {
                     ...base,
                     type: "turn.completed",
@@ -186,6 +167,14 @@ class CodexSession {
                 message: harnessError.message
             };
         }
+        finally {
+            // Returning this outer iterator also returns the SDK's event generator;
+            // its finally block kills the child. Avoid aborting after the SDK has
+            // removed the child's error listener (which would surface AbortError as
+            // an uncaught process error).
+            turn.complete();
+            turn.dispose();
+        }
     }
     *#mapEvent(event, turnId) {
         const raw = { source: "codex.exec.json", method: event.type };
@@ -326,60 +315,78 @@ class CodexSession {
         throw new HarnessError("protocol_parse", "codex exec does not surface interactive approval requests");
     }
     async interrupt() {
-        // The turn is interrupted by aborting the signal passed to sendTurn; the
-        // codex-sdk kills the child on abort. Nothing extra to do here.
+        this.#turns.interrupt();
     }
     resumeCursor() {
         if (this.#sessionId === "codex:pending")
             return undefined;
-        return { version: RESUME_CURSOR_VERSION, kind: this.#kind, data: { threadId: this.#sessionId } };
+        return {
+            version: RESUME_CURSOR_VERSION,
+            kind: this.#kind,
+            data: { threadId: this.#sessionId }
+        };
     }
     async stop() {
-        // A completed/aborted turn already released the child; there is no
-        // long-lived process to stop between turns for codex exec.
+        if (this.#stopped)
+            return;
+        this.#stopped = true;
+        this.#turns.interrupt(new Error("codex session stopped"));
     }
 }
 function resumeThreadId(resume) {
-    if (resume === undefined || resume.kind !== "codex")
-        return undefined;
-    const data = resume.data;
-    return typeof data.threadId === "string" ? data.threadId : undefined;
+    return resumeStringField(resume, "codex", "threadId");
 }
 class CodexInstance {
     kind = "codex";
     #config;
     #context;
     #status;
+    #sessions = new SessionResourceRegistry();
+    #resources = new ResourceScope();
+    #isolatedHome;
     constructor(config, context, status) {
         this.#config = config;
         this.#context = context;
         this.#status = status;
+        this.#isolatedHome = this.#createOwnedHome();
+        // Registered after the home so sessions stop before their rollout files
+        // are removed during LIFO disposal.
+        this.#resources.own(this.#sessions, {
+            finalize: async (sessions) => await sessions.dispose()
+        });
     }
     status() {
         return this.#status;
     }
-    /** An explicit `CODEX_HOME` in the driver env wins over the isolation. */
-    #homeFor() {
+    /**
+     * Gateway-routed sessions use an instance-owned `CODEX_HOME`, preventing the
+     * user's config and model cache from leaking into the routed session. An
+     * explicitly supplied home remains borrowed and is never removed here.
+     */
+    #createOwnedHome() {
         if (this.#config.provider.baseUrl === undefined)
             return undefined;
         const env = resolveDriverEnv(this.#context);
         if (env.CODEX_HOME !== undefined)
             return undefined;
-        return isolatedCodexHome(env);
+        const home = createIsolatedCodexHome("routekit-codex-driver-", env);
+        this.#resources.defer(() => rmSync(home, { recursive: true, force: true }));
+        return home;
     }
     async startSession(options) {
+        this.#sessions.assertOpen();
         if (options.reasoning !== undefined &&
             options.reasoning.mode !== "auto" &&
             options.reasoning.mode !== "effort") {
             throw new HarnessError("invalid_config", `Codex SDK cannot represent reasoning mode "${options.reasoning.mode}"`);
         }
-        const codex = new Codex(codexOptionsFor(this.#config, this.#context, this.#homeFor()));
+        const codex = new Codex(codexOptionsFor(this.#config, this.#context, this.#isolatedHome));
         const threadOptions = {
             sandboxMode: this.#config.sandboxMode,
             approvalPolicy: this.#config.approvalPolicy,
             workingDirectory: options.cwd,
             skipGitRepoCheck: true,
-            ...(options.model ?? this.#config.model !== undefined
+            ...((options.model ?? this.#config.model !== undefined)
                 ? { model: options.model ?? this.#config.model }
                 : {}),
             ...(options.reasoning?.mode === "effort"
@@ -392,11 +399,10 @@ class CodexInstance {
         const thread = resumedId !== undefined
             ? codex.resumeThread(resumedId, threadOptions)
             : codex.startThread(threadOptions);
-        return new CodexSession(thread, resumedId, options.reasoning);
+        return this.#sessions.manage(new CodexSession(thread, resumedId, options.reasoning));
     }
     async dispose() {
-        // Sessions own their (short-lived) child processes; the shared isolated
-        // home outlives the instance so resumable thread rollouts stay available.
+        await this.#resources.dispose();
     }
 }
 /**

package/dist/index.js

@@ -1,4 +1,4 @@
-import { trimTrailingSlashes } from "@velum-labs/routekit-runtime";
+import { gatewayOpenAiBaseUrl } from "@velum-labs/routekit-runtime/network";
 import { codexDriverConfigSchema, createCodexDriver } from "./driver.js";
 import { codexLaunchConfigToml, launchCodex } from "./launch.js";
 const driver = createCodexDriver();
@@ -23,7 +23,7 @@ export const codexTool = {
             sandboxMode: "danger-full-access",
             approvalPolicy: "never",
             provider: {
-                baseUrl: `${trimTrailingSlashes(route.gatewayUrl)}/v1`,
+                baseUrl: gatewayOpenAiBaseUrl(route.gatewayUrl),
                 ...(route.authToken !== undefined ? { apiKey: route.authToken } : {})
             }
         })

package/dist/install.d.ts

@@ -1,11 +1,6 @@
 import type { ModelReasoningCapabilities } from "@velum-labs/routekit-contracts";
 export type CodexInstallProfile = {
     modelId: string;
-    /**
-     * Legacy selector for the one persistent profile. New callers should use
-     * `CodexInstallInput.profileId`; when both are absent it is `routekit`.
-     */
-    profileId?: string;
     description?: string;
     reasoning?: ModelReasoningCapabilities;
 };
@@ -19,12 +14,8 @@ export type CodexInstallOwner = {
 };
 export type CodexInstallInput = {
     gatewayUrl: string;
-    /**
-     * The RouteKit models made available through Codex's model picker.  This
-     * remains named `profiles` for API compatibility, although persistent
-     * installs now write one RouteKit profile rather than one file per model.
-     */
-    profiles: readonly CodexInstallProfile[];
+    /** RouteKit models made available through Codex's model picker. */
+    models: readonly CodexInstallProfile[];
     /** Model selected when the single RouteKit profile is first opened. */
     defaultModel?: string;
     /** Safe selector for the one persistent RouteKit profile. */

package/dist/install.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { parse as tomlParse, stringify as tomlStringify } from "smol-toml";
 import { SUBSCRIPTIONS } from "@velum-labs/routekit-registry";
-import { trimTrailingSlashes } from "@velum-labs/routekit-runtime";
+import { gatewayOpenAiBaseUrl } from "@velum-labs/routekit-runtime/network";
 import { codexPersistentModelCatalogJson, codexProfileFileToml, readCodexHomeModelsCache } from "./launch.js";
 export function codexIntegrationConfigPath(codexHome) {
     if (codexHome !== undefined)
@@ -36,13 +36,13 @@ function profileFileName(selector) {
     return `${selector}.config.toml`;
 }
 function selectedProfileId(input) {
-    return input.profileId ?? input.profiles[0]?.profileId ?? "routekit";
+    return input.profileId ?? "routekit";
 }
 function selectedDefaultModel(input) {
-    const model = input.defaultModel ?? input.profiles[0]?.modelId;
+    const model = input.defaultModel ?? input.models[0]?.modelId;
     if (model === undefined)
         throw new Error("at least one Codex catalog model is required");
-    if (!input.profiles.some((profile) => profile.modelId === model)) {
+    if (!input.models.some((profile) => profile.modelId === model)) {
         throw new Error(`the Codex default model ${JSON.stringify(model)} is not in the RouteKit catalog`);
     }
     return model;
@@ -55,7 +55,7 @@ function orderedCatalogProfiles(profiles, defaultModel) {
 }
 /** Serialize one additive, owner-marked Codex provider block. */
 export function codexIntegrationBlock(input) {
-    const base = trimTrailingSlashes(input.gatewayUrl);
+    const base = gatewayOpenAiBaseUrl(input.gatewayUrl);
     const begin = marker(input.owner.id, "begin");
     const end = marker(input.owner.id, "end");
     const filesComment = profileFilesComment(input.owner.id);
@@ -66,7 +66,7 @@ export function codexIntegrationBlock(input) {
         model_providers: {
             [input.owner.providerId]: {
                 name: `${input.owner.displayName} gateway`,
-                base_url: `${base}/v1`,
+                base_url: base,
                 wire_api: "responses",
                 ...(input.auth !== undefined
                     ? {
@@ -119,7 +119,10 @@ function ownedCatalogFile(managed, codexHome, ownerId) {
     if (line === undefined)
         return undefined;
     const file = line.slice(prefix.length).trim();
-    if (file.length === 0 || file.includes("/") || file.includes("\\") || file !== catalogFileName(ownerId)) {
+    if (file.length === 0 ||
+        file.includes("/") ||
+        file.includes("\\") ||
+        file !== catalogFileName(ownerId)) {
         return undefined;
     }
     return join(codexHome, file);
@@ -185,7 +188,7 @@ function assertProfileFileCanBeManaged(path, ownerId) {
         `rename it, then rerun the RouteKit install`);
 }
 export function installCodexIntegration(input) {
-    if (input.profiles.length === 0)
+    if (input.models.length === 0)
         throw new Error("at least one Codex catalog model is required");
     const defaultModel = selectedDefaultModel(input);
     const profileId = selectedProfileId(input);
@@ -212,20 +215,12 @@ export function installCodexIntegration(input) {
     const persistentProfilePath = join(codexHome, profileFileName(profileId));
     assertProfileFileCanBeManaged(persistentProfilePath, input.owner.id);
     mkdirSync(codexHome, { recursive: true });
-    writeFileSync(catalogPath, codexPersistentModelCatalogJson(orderedCatalogProfiles(input.profiles, defaultModel).map((profile) => ({
+    writeFileSync(catalogPath, codexPersistentModelCatalogJson(orderedCatalogProfiles(input.models, defaultModel).map((profile) => ({
         id: profile.modelId,
         ...(profile.reasoning !== undefined ? { reasoning: profile.reasoning } : {})
     })), readCodexHomeModelsCache(codexHome)[0]), { mode: 0o600 });
     writeFileSync(persistentProfilePath, `# Managed by ${input.owner.id}\n${codexProfileFileToml(defaultModel, input.owner.providerId, catalogPath)}`, { mode: 0o600 });
-    // Write the new profile before replacing the managed block, then clean up
-    // legacy per-model files last. An interrupted migration therefore leaves a
-    // working old or new profile, never a config that points at a missing file.
     writeFileSync(configPath, next);
-    const nextFiles = new Set([persistentProfilePath]);
-    for (const stale of ownedProfileFiles(managed, codexHome, input.owner.id)) {
-        if (!nextFiles.has(stale))
-            removeOwnedProfileFile(stale, input.owner.id);
-    }
     return {
         configPath,
         catalogPath,

package/dist/launch.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { homedir, tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import { codexCompatibility, isCodexPickerEligibleModel, reasoningEffortDescriptors } from "@velum-labs/routekit-contracts";
-import { trimTrailingSlashes } from "@velum-labs/routekit-runtime";
+import { gatewayOpenAiBaseUrl } from "@velum-labs/routekit-runtime/network";
 import { stringify as tomlStringify } from "smol-toml";
 const PROVIDER_ID = "routekit";
 const CATALOG_FILE = "model-catalog.json";
@@ -89,14 +89,13 @@ function codexModelId(modelId) {
 }
 function catalogModels(spec) {
     return spec.models.filter((model) => {
-        const isDefault = model.id === spec.defaultModel ||
-            model.aliases?.includes(spec.defaultModel) === true;
+        const isDefault = model.id === spec.defaultModel || model.aliases?.includes(spec.defaultModel) === true;
         if (spec.modelSelection === undefined) {
             return isDefault || isCodexPickerEligibleModel(model);
         }
         if (isDefault && spec.modelSelection !== "implicit")
             return true;
-        return codexCompatibility({
+        return (codexCompatibility({
             id: model.id,
             ...(model.provider !== undefined ? { provider: model.provider } : {}),
             ...(model.architecture !== undefined ? { architecture: model.architecture } : {}),
@@ -106,14 +105,12 @@ function catalogModels(spec) {
             ...(model.features?.tools !== undefined
                 ? {
                     capabilities: {
-                        tools: model.features.tools === "full"
-                            ? "supported"
-                            : model.features.tools
+                        tools: model.features.tools === "full" ? "supported" : model.features.tools
                     }
                 }
                 : {}),
             ...(model.reasoning !== undefined ? { reasoning: model.reasoning } : {})
-        }).status === "compatible";
+        }).status === "compatible");
     });
 }
 function catalogIds(spec) {
@@ -346,7 +343,7 @@ export function codexLaunchConfigToml(spec, modelCatalogPath, roles = []) {
     if (modelCatalogPath !== undefined) {
         lines.push(`model_catalog_json = ${JSON.stringify(modelCatalogPath)}`);
     }
-    lines.push("", `[model_providers.${PROVIDER_ID}]`, `name = "RouteKit gateway"`, `base_url = ${JSON.stringify(`${trimTrailingSlashes(spec.gatewayUrl)}/v1`)}`, `wire_api = "responses"`, `requires_openai_auth = false`, ...(spec.auth?.token !== undefined ? [`env_key = "ROUTEKIT_GATEWAY_TOKEN"`] : []), "");
+    lines.push("", `[model_providers.${PROVIDER_ID}]`, `name = "RouteKit gateway"`, `base_url = ${JSON.stringify(gatewayOpenAiBaseUrl(spec.gatewayUrl))}`, `wire_api = "responses"`, `requires_openai_auth = false`, ...(spec.auth?.token !== undefined ? [`env_key = "ROUTEKIT_GATEWAY_TOKEN"`] : []), "");
     if (roles.length > 0) {
         lines.push("[features]", "multi_agent = true", "", "[agents]", "max_depth = 1", "");
         for (const role of roles) {
@@ -372,7 +369,7 @@ function codexLaunchOverrides(spec, catalogPath, roles = []) {
         ["model", codexModelId(spec.defaultModel)],
         ["model_provider", PROVIDER_ID],
         [`model_providers.${PROVIDER_ID}.name`, "RouteKit gateway"],
-        [`model_providers.${PROVIDER_ID}.base_url`, `${trimTrailingSlashes(spec.gatewayUrl)}/v1`],
+        [`model_providers.${PROVIDER_ID}.base_url`, gatewayOpenAiBaseUrl(spec.gatewayUrl)],
         [`model_providers.${PROVIDER_ID}.wire_api`, "responses"],
         [`model_providers.${PROVIDER_ID}.requires_openai_auth`, false]
     ];

package/dist/test/driver.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "node:test";
@@ -23,7 +23,7 @@ process.stdin.on("end", () => {
   emit({ type: "thread.started", thread_id: threadId });
   emit({ type: "turn.started" });
   emit({ type: "item.started", item: { id: "i1", type: "agent_message", text: "" } });
-  emit({ type: "item.completed", item: { id: "i1", type: "agent_message", text: "ARGS: " + args.join(" ") + "\\nOK: " + input.trim() } });
+  emit({ type: "item.completed", item: { id: "i1", type: "agent_message", text: "ARGS: " + args.join(" ") + "\\nCODEX_HOME: " + (process.env.CODEX_HOME || "") + "\\nOK: " + input.trim() } });
   emit({ type: "turn.completed", usage: { input_tokens: 3, cached_input_tokens: 0, output_tokens: 2, reasoning_output_tokens: 0 } });
   process.exit(0);
 });
@@ -99,6 +99,80 @@ test("codex driver forwards effort as the SDK CLI config", async () => {
         effortRepo.cleanup();
     }
 });
+test("codex driver releases the turn after reasoning validation fails", async () => {
+    const driver = createCodexDriver();
+    const validationRepo = fakeCodexRepo();
+    const instance = await driver.createInstance(driver.configSchema.parse({ command: validationRepo.command }));
+    try {
+        const session = await instance.startSession({
+            cwd: validationRepo.cwd,
+            reasoning: { mode: "effort", effort: "low" }
+        });
+        await assert.rejects(async () => {
+            for await (const _event of session.sendTurn({
+                prompt: "invalid override",
+                reasoning: { mode: "effort", effort: "high" }
+            })) {
+                // Drain.
+            }
+        }, /reasoning must be selected before the session starts/);
+        const events = [];
+        for await (const event of session.sendTurn({ prompt: "valid retry" })) {
+            events.push(event);
+        }
+        assert.equal(events.find((event) => event.type === "turn.completed")?.endReason, "completed");
+    }
+    finally {
+        await instance.dispose();
+        validationRepo.cleanup();
+    }
+});
+test("gateway-routed codex homes are owned by their harness instance", async () => {
+    const driver = createCodexDriver();
+    const routedRepo = fakeCodexRepo();
+    const userHome = mkdtempSync(join(tmpdir(), "codex-driver-user-"));
+    const context = {
+        env: { ...process.env, HOME: userHome, CODEX_HOME: undefined }
+    };
+    const config = driver.configSchema.parse({
+        command: routedRepo.command,
+        provider: { baseUrl: "http://127.0.0.1:8080/v1" }
+    });
+    const first = await driver.createInstance(config, context);
+    const second = await driver.createInstance(config, context);
+    let firstHome;
+    let secondHome;
+    try {
+        const readHome = async (instance) => {
+            const session = await instance.startSession({ cwd: routedRepo.cwd });
+            const events = [];
+            for await (const event of session.sendTurn({ prompt: "show home" })) {
+                events.push(event);
+            }
+            const text = events
+                .flatMap((event) => (event.type === "content.delta" ? [event.text] : []))
+                .join("");
+            const match = /^CODEX_HOME: (.+)$/m.exec(text);
+            assert.ok(match?.[1]);
+            return match[1];
+        };
+        firstHome = await readHome(first);
+        secondHome = await readHome(second);
+        assert.notEqual(firstHome, secondHome);
+        assert.ok(firstHome.startsWith(join(userHome, ".cache", "routekit", "codex")));
+        assert.ok(secondHome.startsWith(join(userHome, ".cache", "routekit", "codex")));
+        await first.dispose();
+        assert.equal(existsSync(firstHome), false);
+        assert.equal(existsSync(secondHome), true);
+        await second.dispose();
+        assert.equal(existsSync(secondHome), false);
+    }
+    finally {
+        await Promise.allSettled([first.dispose(), second.dispose()]);
+        routedRepo.cleanup();
+        rmSync(userHome, { recursive: true, force: true });
+    }
+});
 test("codex driver probe reports version and installed state", async () => {
     const driver = createCodexDriver();
     const repo2 = fakeCodexRepo();

package/dist/test/install.test.js

@@ -20,7 +20,7 @@ test("Codex managed install adds one picker-backed profile and removes only owne
         const installed = installCodexIntegration({
             gatewayUrl: "http://127.0.0.1:9999/",
             owner: OWNER,
-            profiles: [
+            models: [
                 { modelId: "opaque-primary" },
                 { modelId: "opaque-secondary", description: "Secondary route" }
             ],
@@ -42,7 +42,7 @@ test("Codex managed install adds one picker-backed profile and removes only owne
         const updated = installCodexIntegration({
             gatewayUrl: "http://127.0.0.1:8888",
             owner: OWNER,
-            profiles: [{ modelId: "opaque-primary" }],
+            models: [{ modelId: "opaque-primary" }],
             defaultModel: "opaque-primary",
             codexHome: home
         });
@@ -64,7 +64,7 @@ test("Codex managed install can use a command-backed bearer token", () => {
         installCodexIntegration({
             gatewayUrl: "http://127.0.0.1:9999",
             owner: OWNER,
-            profiles: [{ modelId: "opaque-primary" }],
+            models: [{ modelId: "opaque-primary" }],
             auth: {
                 command: "/opt/routekit/node",
                 args: ["/opt/routekit/index.js", "credential", "get", "--tool", "codex"]
@@ -87,7 +87,8 @@ test("Codex's single persistent profile can use a safe custom selector", () => {
         const result = installCodexIntegration({
             gatewayUrl: "http://127.0.0.1:9999",
             owner: OWNER,
-            profiles: [{ modelId: "provider/model", profileId: "route-1" }],
+            models: [{ modelId: "provider/model" }],
+            profileId: "route-1",
             codexHome: home
         });
         assert.deepEqual(result.profiles, ["route-1"]);
@@ -98,50 +99,6 @@ test("Codex's single persistent profile can use a safe custom selector", () => {
         rmSync(home, { recursive: true, force: true });
     }
 });
-test("Codex reinstall migrates a legacy per-model installation to one RouteKit profile", () => {
-    const home = mkdtempSync(join(tmpdir(), "routekit-codex-migrate-"));
-    const configPath = join(home, "config.toml");
-    const legacyProfiles = ["routekit-model-1.config.toml", "routekit-model-2.config.toml"];
-    writeFileSync(configPath, [
-        'model = "user-default"',
-        "",
-        "# >>> example-host integration >>>",
-        "# example-host-profile-files: routekit-model-1.config.toml routekit-model-2.config.toml",
-        "# example-host-catalog-file: .example-host-model-catalog.json",
-        "",
-        "[model_providers.example_route]",
-        'name = "Example Host gateway"',
-        'base_url = "http://127.0.0.1:9999/v1"',
-        'wire_api = "responses"',
-        "requires_openai_auth = false",
-        'env_key = "ROUTEKIT_GATEWAY_TOKEN"',
-        "",
-        "# <<< example-host integration <<<",
-        ""
-    ].join("\n"));
-    for (const profile of legacyProfiles) {
-        writeFileSync(join(home, profile), "# Managed by example-host\nmodel = \"opaque-primary\"\n");
-    }
-    writeFileSync(join(home, ".example-host-model-catalog.json"), "{\"models\":[]}\n");
-    try {
-        const result = installCodexIntegration({
-            gatewayUrl: "http://127.0.0.1:8888",
-            owner: OWNER,
-            profiles: [{ modelId: "opaque-primary" }, { modelId: "opaque-secondary" }],
-            defaultModel: "opaque-secondary",
-            codexHome: home
-        });
-        assert.equal(result.action, "updated");
-        assert.deepEqual(result.profiles, ["routekit"]);
-        assert.equal(existsSync(join(home, "routekit.config.toml")), true);
-        for (const profile of legacyProfiles)
-            assert.equal(existsSync(join(home, profile)), false);
-        assert.match(readFileSync(configPath, "utf8"), /example-host-profile-files: routekit\.config\.toml/);
-    }
-    finally {
-        rmSync(home, { recursive: true, force: true });
-    }
-});
 test("Codex install refuses to overwrite a user-owned routekit profile", () => {
     const home = mkdtempSync(join(tmpdir(), "routekit-codex-profile-conflict-"));
     const configPath = join(home, "config.toml");
@@ -150,7 +107,7 @@ test("Codex install refuses to overwrite a user-owned routekit profile", () => {
         assert.throws(() => installCodexIntegration({
             gatewayUrl: "http://127.0.0.1:9999",
             owner: OWNER,
-            profiles: [{ modelId: "opaque-primary" }],
+            models: [{ modelId: "opaque-primary" }],
             codexHome: home
         }), /refusing to overwrite an existing Codex profile/);
         assert.equal(existsSync(configPath), false);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-tool-codex",
   "private": false,
-  "version": "0.18.6",
+  "version": "1.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -14,6 +14,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./driver": {
+      "types": "./dist/driver.d.ts",
+      "default": "./dist/driver.js"
+    },
+    "./install": {
+      "types": "./dist/install.d.ts",
+      "default": "./dist/install.js"
+    },
+    "./launch": {
+      "types": "./dist/launch.d.ts",
+      "default": "./dist/launch.js"
     }
   },
   "files": [
@@ -29,11 +41,11 @@
     "@openai/codex-sdk": "0.145.0",
     "smol-toml": "1.7.0",
     "zod": "4.4.3",
-    "@velum-labs/routekit-contracts": "0.18.6",
-    "@velum-labs/routekit-harness-core": "0.18.6",
-    "@velum-labs/routekit-registry": "0.18.6",
-    "@velum-labs/routekit-runtime": "0.18.6",
-    "@velum-labs/routekit-tools": "0.18.6"
+    "@velum-labs/routekit-contracts": "1.0.0",
+    "@velum-labs/routekit-harness-core": "1.0.0",
+    "@velum-labs/routekit-runtime": "1.0.0",
+    "@velum-labs/routekit-registry": "1.0.0",
+    "@velum-labs/routekit-tools": "1.0.0"
   },
   "keywords": [
     "llm",
@@ -43,7 +55,7 @@
     "adapter"
   ],
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsc -p tsconfig.json",
     "clean": "tsc -b --clean",
     "test": "node --test \"dist/test/*.test.js\""
   }