akm-cli 0.9.25-alpha.1 → 0.9.25-alpha.3

package/dist/integrations/harnesses/claude/agent-builder.js

@@ -28,7 +28,6 @@
  *
  * The builder's `platform` stays `'claude'` (the canonical harness id).
  */
-import { isModelWorkTools } from "../../../execution/source.js";
 import { modelFromArgs, normalizeTools, resolveDispatchModel, } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
 /** The model-work tool policy on Claude Code: read, edit in the working directory, `akm search`, `akm show`. */
@@ -45,17 +44,11 @@ export const MODEL_WORK_CLAUDE_FLAGS = Object.freeze([
 /**
  * Claude Code builder.
  * Command shape:
- *   claude [--agent <name>] [--system-prompt "..."] [--model <m>] [--effort <level>]
- *          [--allowedTools <t>] [--output-format json] --print -- "<prompt>"
+ *   claude [--agent <name>] [--system-prompt "..."] [--model <m>] [--allowedTools <t>]
+ *          [--output-format json] --print -- "<prompt>"
  *
  * --print switches Claude Code to non-interactive captured output mode.
  *
- * `--effort` carries the request's `reasoningEffort` as the harness's own
- * level (`low`, `medium`, `high`, `xhigh` or `max` in 2.1.283), passed through
- * as given: a value Claude Code rejects fails the dispatch. It is the only
- * inference field Claude Code takes on its command line, so the others are
- * reported as untranslated.
- *
  * The model-work tool policy lowers to {@link MODEL_WORK_CLAUDE_FLAGS} in place
  * of the engine's `args` and `--allowedTools`, verified against Claude Code
  * 2.1.283 and a local stub:
@@ -78,11 +71,9 @@ export const claudeBuilder = {
         personaChannel: "native",
         nativeAgentSelector: true,
         tools: "all",
-        modelWorkTools: true,
-        inference: ["reasoningEffort"],
     }),
     build(profile, req) {
-        const modelWork = isModelWorkTools(req.tools);
+        const modelWork = req.modelWork === true;
         const args = modelWork ? [...MODEL_WORK_CLAUDE_FLAGS] : [...profile.args];
         if (req.agent) {
             args.push("--agent", req.agent);
@@ -99,10 +90,7 @@ export const claudeBuilder = {
             if (model)
                 args.push("--model", model);
         }
-        const effort = req.inference?.reasoningEffort;
-        if (typeof effort === "string" && effort.length > 0)
-            args.push("--effort", effort);
-        if (req.tools && !modelWork) {
+        if (req.tools) {
             args.push("--allowedTools", normalizeTools(req.tools));
         }
         if (req.schema) {

package/dist/integrations/harnesses/codex/agent-builder.js

@@ -43,8 +43,7 @@
  *     field yet); {@link codexResumeArgs} exposes the argv prefix for the
  *     integration task that wires session-id reuse from `workflow_run_units`.
  *   - The request's inference is not translated: the shared lowering reports
- *     each field as untranslated (`inference` in `harnesses/ids.ts` lists none
- *     for codex). codex would take `reasoningEffort` as
+ *     each field as untranslated. codex would take `reasoningEffort` as
  *     `-c model_reasoning_effort=<v>`, which is left to the integration task.
  *
  * Registered: `codexBuilder` is `CodexHarness.agentBuilder` (`./index.ts`),

package/dist/integrations/harnesses/codex/index.js

@@ -1,23 +1,14 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/**
- * OpenAI Codex CLI harness (P2 integration, plan §"The adapter contract").
- *
- * Per-harness barrel gathering the Codex integration surfaces:
- *   - agent command builder → ./agent-builder.ts    (codexBuilder)
- *   - result extractor      → ./result-extractor.ts (codexResultExtractor)
- *
- * It also defines {@link CodexHarness}, the {@link AkmHarness} descriptor that
- * `HARNESS_REGISTRY` registers. Dispatch-only: no native session-log reader or
- * config importer yet.
- */
 import { caps } from "../shared.js";
 import { BaseHarness } from "../types.js";
 import { codexBuilder } from "./agent-builder.js";
 import { codexResultExtractor } from "./result-extractor.js";
+import { CodexProvider } from "./session-log.js";
 export { codexBuilder, codexResumeArgs, writeCodexOutputSchemaFile } from "./agent-builder.js";
 export { codexResultExtractor } from "./result-extractor.js";
+export { CodexProvider } from "./session-log.js";
 /**
  * OpenAI Codex CLI.
  *
@@ -26,6 +17,8 @@ export { codexResultExtractor } from "./result-extractor.js";
 export class CodexHarness extends BaseHarness {
     id = "codex";
     displayName = "OpenAI Codex CLI";
+    // No `setupDetectionDir`: `~/.codex` holds credentials and session rollouts,
+    // not assets, so `akm setup` must not offer it as a stash source.
     agentBuilder = codexBuilder;
     resultExtractor = codexResultExtractor;
     // ── Workflow-engine descriptor (plan §"Capability matrix", P2) ────────────
@@ -40,7 +33,9 @@ export class CodexHarness extends BaseHarness {
     // user config-dir var commonly exported in shell profiles, so it would stamp
     // identity onto manual runs (see `AkmHarness.presenceEnv`).
     presenceEnv = ["CODEX_SANDBOX"];
+    sessionLogProvider = () => new CodexProvider();
     capabilities = caps({
+        sessionLogs: true,
         agentDispatch: true,
         detection: true,
     });

package/dist/integrations/harnesses/codex/session-log.js

@@ -0,0 +1,211 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
+import { AbstractSessionLogProvider } from "../../session-logs/provider-base.js";
+/**
+ * Root directory holding Codex's rollout files, one per session, as
+ * `YYYY/MM/DD/rollout-<timestamp>-<thread-id>.jsonl`.
+ *
+ * Resolved per call (not memoized at module load) so `CODEX_HOME` — Codex's own
+ * override of `~/.codex` — can be set after import; tests point it at a fixture
+ * directory instead of the real history.
+ */
+function codexSessionsDir() {
+    return path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "sessions");
+}
+/** Bytes read to get a rollout's first record, `session_meta`: its embedded base instructions make it 20-50 KB. */
+const META_PEEK_BYTES = 128 * 1024;
+/**
+ * User-role blocks Codex injects itself, which are not the person's words: the
+ * AGENTS.md instructions and the context tags it is known to wrap (environment,
+ * plugin recommendations, an invoked skill's text, ...). Any other block is kept:
+ * a stray bit of context costs less than a dropped reply.
+ */
+const INJECTED_CONTEXT_RE = /^\s*(?:# AGENTS\.md instructions[\s\S]*<\/INSTRUCTIONS>|<(environment_context|user_instructions|recommended_plugins|skill|turn_aborted)>[\s\S]*<\/\1>)\s*$/i;
+/** The `session_meta` record, always a rollout's first; `undefined` for any other record. */
+function parseSessionMeta(entry) {
+    const e = entry;
+    if (e?.type !== "session_meta" || !e.payload)
+        return undefined;
+    const { timestamp, cwd, source } = e.payload;
+    const startedAt = typeof timestamp === "string" ? Date.parse(timestamp) : Number.NaN;
+    return {
+        ...(Number.isNaN(startedAt) ? {} : { startedAt }),
+        ...(typeof cwd === "string" ? { cwd } : {}),
+        isAgent: typeof source === "object" && source !== null && ("subagent" in source || "internal" in source),
+    };
+}
+/** The text of a message's or tool output's content: a plain string, or blocks whose images and audio carry none. */
+function blockText(blocks, keep = () => true) {
+    if (typeof blocks === "string")
+        return blocks;
+    if (!Array.isArray(blocks))
+        return "";
+    const parts = [];
+    for (const block of blocks) {
+        const text = block?.text;
+        if (typeof text === "string" && keep(text))
+            parts.push(text);
+    }
+    return parts.join("\n");
+}
+/**
+ * A tool call's input as text. A shell call surfaces its command line (`cmd`, or
+ * `command` as a string or an argv array) so the inline-ref scanner can match
+ * `akm remember "..."` without JSON-quote escaping mangling the regex; any
+ * other input stays as it was written.
+ */
+function toolInputText(input) {
+    let args = input;
+    if (typeof input === "string") {
+        try {
+            args = JSON.parse(input);
+        }
+        catch {
+            return input;
+        }
+    }
+    const fields = args && typeof args === "object" ? args : {};
+    const cmd = fields.cmd ?? fields.command;
+    if (typeof cmd === "string")
+        return cmd;
+    if (Array.isArray(cmd))
+        return cmd.join(" ");
+    return typeof input === "string" ? input : (JSON.stringify(input) ?? "");
+}
+/**
+ * Parse one rollout record into a normalized {@link SessionEvent}. The
+ * conversation lives in `response_item` records; the rest (`event_msg` UI events
+ * that repeat it, `turn_context`, `world_state`, token counts, compaction
+ * markers) and items with nothing to read (`reasoning` is encrypted) give
+ * `undefined`. Codex's `developer` messages are its own instructions, so they
+ * are skipped too.
+ *
+ * Tool calls become `[tool:<name>] <input>` and their results `[tool_result]
+ * <output>`, the shapes the Claude reader writes. A result is a `tool` event:
+ * Codex has no enclosing user message to give it.
+ */
+function parseCodexRecord(entry, sessionId, filePath, fallbackTsMs) {
+    const e = entry;
+    const item = e?.type === "response_item" ? e.payload : undefined;
+    if (!item)
+        return undefined;
+    const toolName = typeof item.name === "string" ? item.name : "tool";
+    let role = "assistant";
+    let text;
+    switch (item.type) {
+        case "message":
+            if (item.role !== "user" && item.role !== "assistant")
+                return undefined;
+            role = item.role;
+            text = blockText(item.content, item.role === "user" ? (t) => !INJECTED_CONTEXT_RE.test(t) : undefined);
+            break;
+        case "function_call":
+            text = `[tool:${toolName}] ${toolInputText(item.arguments)}`;
+            break;
+        case "custom_tool_call":
+            text = `[tool:${toolName}] ${typeof item.input === "string" ? item.input : ""}`;
+            break;
+        case "local_shell_call":
+            text = `[tool:shell] ${toolInputText(item.action)}`;
+            break;
+        case "function_call_output":
+        case "custom_tool_call_output": {
+            role = "tool";
+            const output = blockText(item.output);
+            text = output ? `[tool_result] ${output}` : "";
+            break;
+        }
+        default:
+            return undefined;
+    }
+    if (!text.trim())
+        return undefined;
+    const ts = typeof e?.timestamp === "string" ? Date.parse(e.timestamp) || fallbackTsMs : fallbackTsMs;
+    return { harness: "codex", text, ts, sessionId, role, filePath };
+}
+/**
+ * Codex native session-log reader.
+ *
+ * Events, refs, extraction keys, and the harness registry all use `codex`. The
+ * session id is the thread id in the rollout's file name (the id `codex resume`
+ * takes) and `projectHint` is the session's working directory.
+ */
+export class CodexProvider extends AbstractSessionLogProvider {
+    name = "codex";
+    availabilityRoot() {
+        return codexSessionsDir();
+    }
+    listSessions(input = {}) {
+        return this.listSessionsFromFiles({
+            sinceMs: input.sinceMs ?? 0,
+            enumerate: () => this.walkFiles(input.location ?? codexSessionsDir(), (name) => /^rollout-.+\.jsonl$/.test(name)),
+            summarize: (rolloutPath, stat) => {
+                const meta = this.#peekMeta(rolloutPath);
+                if (meta?.isAgent)
+                    return undefined;
+                return this.sessionRef({
+                    // The thread id is the 36-character UUID that ends the file name.
+                    sessionId: path.basename(rolloutPath, ".jsonl").slice(-36),
+                    filePath: rolloutPath,
+                    startedAt: meta?.startedAt ?? stat.ctimeMs,
+                    endedAt: stat.mtimeMs,
+                    projectHint: meta?.cwd,
+                });
+            },
+        });
+    }
+    readSession(ref) {
+        const stat = fs.statSync(ref.filePath);
+        const events = [];
+        const inlineRefs = [];
+        let meta;
+        for (const line of fs.readFileSync(ref.filePath, "utf8").split("\n").filter(Boolean)) {
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue; // a partial line (the session is still being written) or garbage
+            }
+            meta ??= parseSessionMeta(entry);
+            const parsed = parseCodexRecord(entry, ref.sessionId, ref.filePath, stat.mtimeMs);
+            if (!parsed)
+                continue;
+            events.push(parsed);
+            inlineRefs.push(...extractInlineRefMentions(parsed.text, parsed.ts));
+        }
+        return {
+            ref: this.sessionRef({
+                sessionId: ref.sessionId,
+                filePath: ref.filePath,
+                startedAt: meta?.startedAt ?? events[0]?.ts ?? stat.ctimeMs,
+                endedAt: events[events.length - 1]?.ts ?? stat.mtimeMs,
+                projectHint: meta?.cwd,
+            }),
+            events,
+            inlineRefs,
+        };
+    }
+    /** The `session_meta` record on a rollout's first line, read without loading the file. */
+    #peekMeta(filePath) {
+        try {
+            const fd = fs.openSync(filePath, "r");
+            try {
+                const head = Buffer.alloc(META_PEEK_BYTES);
+                const firstLine = head.toString("utf8", 0, fs.readSync(fd, head, 0, head.length, 0)).split("\n", 1)[0] ?? "";
+                return parseSessionMeta(JSON.parse(firstLine));
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        catch {
+            return undefined; // unreadable / vanished file, or a first line that is not one whole record
+        }
+    }
+}

package/dist/integrations/harnesses/ids.js

@@ -1,19 +1,17 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-/** What opencode carries on a model; see `harnesses/opencode/model-config.ts`. */
-const OPENCODE_INFERENCE = ["temperature", "maxTokens", "contextLength", "enableThinking", "reasoningEffort"];
 export const HARNESS_ID_TABLE = [
-    { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true, inference: OPENCODE_INFERENCE },
-    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true, inference: ["reasoningEffort"] },
-    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true, inference: OPENCODE_INFERENCE },
-    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
-    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false, inference: [] },
+    { id: "opencode", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "claude", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "opencode-sdk", agentDispatch: true, enforcesModelWorkTools: true },
+    { id: "codex", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "copilot", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "pi", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "gemini", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "aider", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "amazonq", agentDispatch: true, enforcesModelWorkTools: false },
+    { id: "openhands", agentDispatch: true, enforcesModelWorkTools: false },
 ];
 /**
  * Canonical, ordered list of valid harness / platform ids — the
@@ -26,7 +24,3 @@ export const VALID_HARNESS_IDS = Object.freeze(HARNESS_ID_TABLE.map((h) => h.id)
 export const HARNESS_AGENT_DISPATCH_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.agentDispatch).map((h) => h.id));
 /** Harness ids that confine the model-work tool policy, so unattended model work may run on them. */
 export const HARNESS_MODEL_WORK_IDS = new Set(HARNESS_ID_TABLE.filter((h) => h.enforcesModelWorkTools).map((h) => h.id));
-/** The inference keys an agent engine on `platform` may set; none for a platform that is not registered. */
-export function harnessInferenceKeys(platform) {
-    return HARNESS_ID_TABLE.find((h) => h.id === platform)?.inference ?? [];
-}

package/dist/integrations/harnesses/opencode/agent-builder.js

@@ -14,11 +14,10 @@
  * pre-migration `opencodeBuilder`. The builder's `platform` stays `'opencode'`
  * (the canonical harness id).
  */
-import { isModelWorkTools } from "../../../execution/source.js";
 import { modelFromArgs, resolveDispatchModel } from "../../agent/builder-shared.js";
 import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-import { opencodeCarriedKeys, opencodeInferenceConfig, opencodeModelConfig, splitOpencodeModel } from "./model-config.js";
-import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig } from "./model-work-agent.js";
+import { MODEL_WORK_AGENT_INFERENCE, opencodeInferenceConfig } from "./model-config.js";
+import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig, modelWorkPluginEnv } from "./model-work-agent.js";
 /**
  * OpenCode builder.
  * Command shape: opencode run [--agent <name>] [--model <m>] -- "<prompt>"
@@ -36,11 +35,9 @@ import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig } from "./model-work
  * of the injected config or the scratch working directory. Only the model they
  * name is kept.
  *
- * Inference reaches the run the same way (`./model-config.ts`): the model it
- * names gets an entry in the injected config, which merges over the user's own
- * config for that model, and model work's agent carries the options, whether
- * or not a model is named. A dispatch whose request carries no translatable
- * inference injects nothing, so its argv and env are as they were.
+ * Model work's agent carries the request's inference options
+ * (`./model-config.ts`). Any other dispatch injects nothing and carries none, so
+ * the model's own opencode config applies: set inference there.
  */
 export const opencodeBuilder = {
     platform: "opencode",
@@ -50,19 +47,12 @@ export const opencodeBuilder = {
         personaChannel: "prompt",
         nativeAgentSelector: true,
         tools: "none",
-        modelWorkTools: true,
-        inference: (profile, request) => {
-            const model = request.model?.resolved ?? modelFromArgs(profile.args);
-            return opencodeCarriedKeys(model !== undefined && splitOpencodeModel(model) !== undefined, request.inference, isModelWorkTools(request.tools));
-        },
+        inference: MODEL_WORK_AGENT_INFERENCE,
     }),
     build(profile, req) {
-        const model = req.model ?? modelFromArgs(profile.args);
-        const modelWork = isModelWorkTools(req.tools);
-        // What goes on the model needs a `provider/model` to go on; model work's agent options do not.
-        const { entry, agentOptions } = opencodeInferenceConfig(req.inference, modelWork);
-        const modelConfig = opencodeModelConfig(model, entry);
-        if (modelWork) {
+        if (req.modelWork) {
+            const model = req.model ?? modelFromArgs(profile.args);
+            const { agentOptions } = opencodeInferenceConfig(req.inference, true);
             return {
                 argv: [
                     profile.bin,
@@ -73,7 +63,10 @@ export const opencodeBuilder = {
                     "--",
                     req.prompt,
                 ],
-                env: { OPENCODE_CONFIG_CONTENT: JSON.stringify({ ...modelWorkOpencodeConfig(agentOptions), ...modelConfig }) },
+                env: {
+                    ...modelWorkPluginEnv(),
+                    OPENCODE_CONFIG_CONTENT: JSON.stringify(modelWorkOpencodeConfig(agentOptions)),
+                },
             };
         }
         const args = req.model ? [] : [...profile.args];
@@ -99,9 +92,6 @@ export const opencodeBuilder = {
         }
         args.push("--");
         args.push(req.prompt);
-        return {
-            argv: [profile.bin, ...args],
-            ...(modelConfig ? { env: { OPENCODE_CONFIG_CONTENT: JSON.stringify(modelConfig) } } : {}),
-        };
+        return { argv: [profile.bin, ...args] };
     },
 };

package/dist/integrations/harnesses/opencode/model-config.js

@@ -1,80 +1,33 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/** The inference keys model work's agent carries as options. */
+export const MODEL_WORK_AGENT_INFERENCE = ["temperature", "reasoningEffort", "enableThinking"];
 const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
 /**
- * What opencode carries of `inference`, and the keys that covers. A key it
- * cannot carry is left out: one of the wrong type, or `maxTokens` or
- * `contextLength` without the other. An explicit `null` clears a field, so it
- * is carried as nothing.
+ * Split `inference` into opencode config: `entry` for a model (its options, and
+ * its limit), and for model work `agentOptions` for the confined agent in place
+ * of the entry's options. A value of the wrong type is left out.
  */
-export function carriedInference(inference) {
-    const carried = {};
+export function opencodeInferenceConfig(inference, modelWork) {
     const { temperature, reasoningEffort, enableThinking, maxTokens, contextLength } = inference ?? {};
+    const options = {};
     if (typeof temperature === "number" && Number.isFinite(temperature))
-        carried.temperature = temperature;
+        options.temperature = temperature;
     if (typeof reasoningEffort === "string" && reasoningEffort.length > 0)
-        carried.reasoningEffort = reasoningEffort;
-    if (typeof enableThinking === "boolean")
-        carried.enableThinking = enableThinking;
-    const limit = isPositiveInteger(maxTokens) && isPositiveInteger(contextLength);
-    if (limit)
-        carried.limit = { context: contextLength, output: maxTokens };
-    const keys = [
-        ["temperature", carried.temperature !== undefined, temperature],
-        ["reasoningEffort", carried.reasoningEffort !== undefined, reasoningEffort],
-        ["enableThinking", carried.enableThinking !== undefined, enableThinking],
-        ["maxTokens", limit, maxTokens],
-        ["contextLength", limit, contextLength],
-    ]
-        .filter(([, isCarried, value]) => isCarried || value === null)
-        .map(([key]) => key);
-    return { carried, keys };
-}
-/** opencode's own split of `provider/model`: at the first slash, so a model id may contain slashes. */
-export function splitOpencodeModel(model) {
-    const slash = model.indexOf("/");
-    if (slash <= 0 || slash === model.length - 1)
-        return undefined;
-    return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
-}
-/**
- * The inference keys opencode carries for a dispatch. With a model to attach
- * them to (`attachable`) it carries all of them. Without one it carries only
- * what the model-work agent can, which is every option but the limit; any
- * other dispatch carries nothing.
- */
-export function opencodeCarriedKeys(attachable, inference, modelWork) {
-    const { keys } = carriedInference(inference);
-    if (attachable)
-        return keys;
-    return modelWork ? keys.filter((key) => key !== "maxTokens" && key !== "contextLength") : [];
-}
-/** Split `inference` between the model and, for model work, the confined agent (see the module comment). */
-export function opencodeInferenceConfig(inference, modelWork) {
-    const { carried } = carriedInference(inference);
-    const options = {};
-    if (carried.temperature !== undefined)
-        options.temperature = carried.temperature;
-    if (carried.reasoningEffort !== undefined)
-        options.reasoningEffort = carried.reasoningEffort;
-    if (carried.enableThinking !== undefined) {
-        options.chat_template_kwargs = { enable_thinking: carried.enableThinking };
-        options.enable_thinking = carried.enableThinking;
+        options.reasoningEffort = reasoningEffort;
+    if (typeof enableThinking === "boolean") {
+        options.chat_template_kwargs = { enable_thinking: enableThinking };
+        options.enable_thinking = enableThinking;
     }
     const hasOptions = Object.keys(options).length > 0;
     return {
         entry: {
             ...(hasOptions && !modelWork ? { options } : {}),
-            ...(carried.limit ? { limit: { ...carried.limit } } : {}),
+            ...(isPositiveInteger(maxTokens) && isPositiveInteger(contextLength)
+                ? { limit: { context: contextLength, output: maxTokens } }
+                : {}),
         },
         ...(hasOptions && modelWork ? { agentOptions: options } : {}),
     };
 }
-/** The config that gives `model` (`provider/model`) `entry`: undefined when the model cannot be split or `entry` is empty. */
-export function opencodeModelConfig(model, entry) {
-    const target = model === undefined ? undefined : splitOpencodeModel(model);
-    if (!target || Object.keys(entry).length === 0)
-        return undefined;
-    return { provider: { [target.providerID]: { models: { [target.modelID]: entry } } } };
-}