@jini-ai/daemon 0.5.3 → 0.6.0

package/dist/agent-executor/launch.js

@@ -2,7 +2,7 @@ import { spawn as nodeSpawn, } from 'node:child_process';
 import { promises as fsPromises, } from 'node:fs';
 import { tmpdir, } from 'node:os';
 import { join, } from 'node:path';
-import { agentCapabilities, applyAgentLaunchEnv, ensureAgentCapabilities, getAgentDef, resolveAgentLaunch, attachAcpSession, attachPiRpcSession, checkPromptArgvBudget, checkWindowsCmdShimCommandLineBudget, checkWindowsDirectExeCommandLineBudget, prepareAgentLogFile, preparePromptFileForAgent, } from '@jini-ai/agent-runtime';
+import { agentCapabilities, applyAgentLaunchEnv, ensureAgentCapabilities, resolveModelForLaunch, getAgentDef, resolveAgentLaunch, attachAcpSession, attachPiRpcSession, checkPromptArgvBudget, checkWindowsCmdShimCommandLineBudget, checkWindowsDirectExeCommandLineBudget, prepareAgentLogFile, preparePromptFileForAgent, } from '@jini-ai/agent-runtime';
 import { collectProcessTreePids, createCommandInvocation, listProcessSnapshots, stopProcesses, } from '@jini-ai/platform';
 import { applyImagePromptDelivery, } from '../image-prompt-delivery.js';
 import { SUPPORTED_STREAM_FORMATS, AgentExecutorError, } from './contracts.js';
@@ -640,6 +640,18 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
         await lifecycle.finish({ runId, status: 'failed', code: null, signal: null, resumable: false });
         throw new AgentExecutorError({ code: code, message: message });
     }
+    /**
+     * Every run with a live child, keyed by run id, mapped to how a mid-run message reaches it — the
+     * stdin handle's `sendUserMessage` for a stdin-driven run, a constant `'unsupported'` for an
+     * ACP/pi run (whose RPC takes one prompt per turn). Removed on the child's `'close'`, so a
+     * finished or unknown run reads as `'not-running'`. Bounded by the number of live children.
+     */
+    const liveRunInputs = new Map();
+    /** `AgentExecutor.sendUserMessage()` — see that interface method's own doc. @complexity O(1). */
+    async function sendUserMessage({ runId, text }) {
+        const deliver = liveRunInputs.get(runId);
+        return deliver ? deliver(text) : 'not-running';
+    }
     /**
      * `AgentExecutor.run()` — see that interface method's own doc for the
      * public contract. Implementation note on shape: every guard below
@@ -706,6 +718,23 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
         const resolvedEnv = { ...(def.env ?? {}), ...resolveRunEnv({ input: input, hostEnv: process.env }) };
         const launch = await resolveLaunch({ input: { runId: input.runId, def, resolvedEnv }, deps: { resolveAgentLaunch: resolveAgentLaunchFn, failBeforeSpawn } });
         const spawnEnv = applyAgentLaunchEnvFn({ env: { ...resolvedEnv }, launch });
+        // Resolve from the launch environment before staging or sending any prompt. Pin the same
+        // concrete ID that the picker displays; an opaque native route cannot silently start a run.
+        let modelCatalog;
+        try {
+            const selection = await (options.resolveModelForLaunch ?? resolveModelForLaunch)({ def, context: {
+                    executable: launch.launchPath, cwd: input.cwd, env: spawnEnv,
+                    ...(input.model && input.model !== 'default' ? { model: input.model } : {}),
+                    ...(input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {}),
+                    ...(input.settingSources ? { settingSources: input.settingSources } : {}),
+                    ...(input.settings ? { settings: input.settings } : {}),
+                } });
+            input.model = selection.model;
+            modelCatalog = selection.catalog;
+        }
+        catch {
+            return failBeforeSpawn({ runId: input.runId, code: 'AGENT_MODEL_UNRESOLVED', message: 'AgentExecutor: pick a concrete model; the starting model could not be resolved for this launch.' });
+        }
         // Fill the def's `--help` capability gate before `buildArgs` reads it. Without this, only a
         // host that happened to call `detectAgents` in THIS process ever had the gate filled, so e.g.
         // `claude` never got `--include-partial-messages` (no streamed text). Probes once per binary;
@@ -898,6 +927,8 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
         const formatForStdin = { streamFormat };
         const stdinHandle = isStdinDrivenFormat(formatForStdin)
             ? wireChildLifecycle({
+                startingModel: input.model,
+                modelCatalog,
                 runId: input.runId,
                 def,
                 streamFormat: formatForStdin.streamFormat,
@@ -915,7 +946,18 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
                 expectsJiniBridge: writtenMcpJsonPath !== undefined,
             })
             : null;
-        await confirmChildSpawned({ input: { runId: input.runId, def, child }, deps: { releaseStagedResources, failBeforeSpawn } });
+        // Registered with the lifecycle wiring above, before the spawn-confirmation await, so a child
+        // that closes immediately never leaves a stale entry behind.
+        const runId = input.runId;
+        liveRunInputs.set(runId, stdinHandle ? stdinHandle.sendUserMessage : async () => 'unsupported');
+        child.once('close', () => liveRunInputs.delete(runId));
+        try {
+            await confirmChildSpawned({ input: { runId: input.runId, def, child }, deps: { releaseStagedResources, failBeforeSpawn } });
+        }
+        catch (error) {
+            liveRunInputs.delete(runId);
+            throw error;
+        }
         // Now — and only now — is there a live process that could consume the locked side effect, so
         // this is where a def's handoff watcher starts. Deliberately not awaited: the whole point is to
         // release the lock as soon as the child confirms the handoff, in parallel with this run
@@ -937,6 +979,7 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
                     prompt: `${overlayDelivery.promptPrefix}${input.prompt}`,
                     cwd: input.cwd,
                     model: input.model,
+                    modelCatalog,
                     imagePaths: input.imagePaths ?? [],
                     envFormat: def.acpMcpEnvFormat,
                     mcpBridge,
@@ -967,6 +1010,7 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
                     prompt: `${overlayDelivery.promptPrefix}${input.prompt}`,
                     cwd: input.cwd,
                     model: input.model,
+                    modelCatalog,
                     imagePaths: input.imagePaths ?? [],
                     uploadRoot: input.uploadRoot,
                 }, deps: {
@@ -998,6 +1042,6 @@ export function createAgentExecutor(requiredArgs, optionalArgs = {}) {
             stdinHandle.imageContents = input.imageContents;
         writePromptToStdin(def, child, stdinPrompt, stdinHandle);
     }
-    return { run };
+    return { run, sendUserMessage };
 }
 //# sourceMappingURL=launch.js.map

package/dist/agent-executor/mcp-bridge.d.ts

@@ -1,5 +1,5 @@
-import { type AcpMcpServerInput, type RuntimeAgentDef } from '@jini-ai/agent-runtime';
-import { type McpJsonInjectionOptions, type McpJsonServerEntry, type McpBridgeDelivery, type PreparedCodexHome, type PreparedClaudeConfigDir, type ClaudeConfigDirIsolationOptions, type FailBeforeSpawn } from './contracts.js';
+import type { AcpMcpServerInput, RuntimeAgentDef } from '@jini-ai/agent-runtime';
+import type { McpJsonInjectionOptions, McpJsonServerEntry, McpBridgeDelivery, PreparedCodexHome, PreparedClaudeConfigDir, ClaudeConfigDirIsolationOptions, FailBeforeSpawn } from './contracts.js';
 /** The run-error code a run gets when its CLI reports the injected `jini` bridge as anything but connected. */
 export declare const MCP_BRIDGE_UNAVAILABLE = "MCP_BRIDGE_UNAVAILABLE";
 /**

package/dist/agent-executor/mcp-bridge.js

@@ -1,9 +1,7 @@
 import { promises as fsPromises, } from 'node:fs';
 import { homedir, tmpdir, } from 'node:os';
-import { join, } from 'node:path';
-import {} from '@jini-ai/agent-runtime';
+import { join, resolve, } from 'node:path';
 import { isRecord, errorMessage, } from './values.js';
-import {} from './contracts.js';
 const JINI_MCP_SERVER_KEY = 'jini';
 /** The run-error code a run gets when its CLI reports the injected `jini` bridge as anything but connected. */
 export const MCP_BRIDGE_UNAVAILABLE = 'MCP_BRIDGE_UNAVAILABLE';
@@ -554,12 +552,23 @@ function defaultMkdtempCodexHome({ prefix }) {
 function defaultRemoveCodexHomeDir({ path }) {
     return fsPromises.rm(path, { recursive: true, force: true });
 }
+/** Config credentials stay run-scoped, but rollouts must survive both completion and cancellation.
+ * Native directory links keep Codex as the sole writer of its own persisted session format.
+ * Cleanup removes the links themselves, never their targets. Two fixed directories, O(1) I/O. */
+async function defaultLinkCodexSessionStore({ runHome, sourceHome }, _optional = {}) {
+    for (const name of ['sessions', 'archived_sessions']) {
+        const target = resolve(sourceHome, name);
+        await fsPromises.mkdir(target, { recursive: true, mode: 0o700 });
+        await fsPromises.symlink(target, join(runHome, name), 'junction');
+    }
+}
 function resolveCodexHomeSeams(options) {
     return {
         mkdtemp: options.mkdtemp ?? defaultMkdtempCodexHome,
         readFile: options.readFile ?? defaultReadMcpJsonFile,
         writeFile: options.writeFile ?? defaultWriteMcpJsonFile,
         removeDir: options.removeDir ?? defaultRemoveCodexHomeDir,
+        linkSessionStore: options.linkSessionStore ?? defaultLinkCodexSessionStore,
     };
 }
 /**
@@ -575,8 +584,9 @@ function resolveCodexHomeSeams(options) {
  *     0.151.0) to fail fast with a structured `401 Unauthorized` stream event, never an interactive
  *     login prompt or a hang — see `defs/codex.ts`'s module doc for the full transcript summary.
  *
- * **Never touches the real `CODEX_HOME`.** `sourceCodexHomeDir` is read-only throughout; nothing is
- * ever written back to it.
+ * **Never changes the real config or credentials.** Those source files stay read-only. Only the
+ * native rollout directories are shared: deleting a run's scratch home must not erase the thread
+ * whose id the host already persisted. No copied login or run-bound MCP credential is retained.
  *
  * A failure after the directory is created (a rejecting `writeFile`, most plausibly) does not leak
  * it: the directory may already hold a partial `config.toml` or a copied credential, so the
@@ -586,9 +596,9 @@ function resolveCodexHomeSeams(options) {
  * `@jini-ai/agent-runtime`'s `prepareAgentLogFile`'s `label` is.
  * @param entry - The shared bridge entry.
  * @param sourceCodexHomeDir - Where to read the real install's `config.toml`/`auth.json` from — see {@link resolveSourceCodexHomeDir}.
- * @param seams - Injectable mkdtemp/readFile/writeFile/removeDir, real filesystem by default.
- * @throws Whatever `mkdtemp`/`writeFile` rejects with — the caller ({@link prepareCodexHomeIfNeeded}) turns that into a pre-spawn `AGENT_SPAWN_FAILED` failure, matching {@link writeMcpJsonForRun}'s own contract.
- * @complexity O(1) plus one directory creation and up to two best-effort file read/write round trips.
+ * @param seams - Injectable mkdtemp/readFile/writeFile/removeDir/linkSessionStore, real filesystem by default.
+ * @throws Whatever staging rejects with — the caller ({@link prepareCodexHomeIfNeeded}) turns that into a pre-spawn `AGENT_SPAWN_FAILED` failure, matching {@link writeMcpJsonForRun}'s own contract.
+ * @complexity O(1): fixed directory links and up to two best-effort file read/write round trips.
  * @overallScore 100/100
  */
 async function prepareCodexHomeForRun(runId, entry, sourceCodexHomeDir, seams) {
@@ -618,6 +628,7 @@ async function prepareCodexHomeForRun(runId, entry, sourceCodexHomeDir, seams) {
             // No stored login (or unreadable) — the spawned CLI runs unauthenticated. Confirmed above:
             // this fails the run fast and observably, never as a hang.
         }
+        await seams.linkSessionStore({ runHome: dir, sourceHome: sourceCodexHomeDir }, {});
     }
     catch (err) {
         await seams.removeDir({ path: dir }).catch(() => {

package/dist/agent-executor/model-receipts.d.ts

@@ -0,0 +1,6 @@
+import type { RunAgentPayload } from '@jini-ai/protocol';
+import { type DiscoveredModel } from '@jini-ai/agent-runtime';
+/** Status metadata comes from CLI/RPC frames, never generated text. Dedupe repeats and record
+ * each observed transition separately so durable run events can describe model switches. */
+export declare function createModelReceiptTracker(startingModel?: string, models?: readonly DiscoveredModel[]): (payload: RunAgentPayload) => RunAgentPayload | null;
+//# sourceMappingURL=model-receipts.d.ts.map

package/dist/agent-executor/model-receipts.js

@@ -0,0 +1,26 @@
+import { modelIdentityKind } from '@jini-ai/agent-runtime';
+/** Status metadata comes from CLI/RPC frames, never generated text. Dedupe repeats and record
+ * each observed transition separately so durable run events can describe model switches. */
+export function createModelReceiptTracker(startingModel, models = []) {
+    // The catalog is launch-scoped evidence. Normalize both the pinned and reported names
+    // so a CLI's alias/display spelling does not fabricate a durable model transition.
+    const normalize = (id) => {
+        const row = models.find(model => model.id === id) || models.find(model => model.label === id);
+        return row?.resolvedId || row?.id || id;
+    };
+    let current = startingModel && normalize(startingModel);
+    return (payload) => {
+        if (payload.type !== 'status' || !payload.model || typeof payload.model !== 'string')
+            return null;
+        const observed = normalize(payload.model);
+        if (modelIdentityKind(observed) !== 'concrete')
+            return null;
+        if (observed === current)
+            return null;
+        const prior = current;
+        current = observed;
+        return { type: 'status', label: prior ? 'model_switch' : 'observed_model', model: current,
+            ...(prior ? { previousModel: prior, detail: `Previous model: ${prior}` } : {}) };
+    };
+}
+//# sourceMappingURL=model-receipts.js.map