operon-agents 0.1.0-alpha.29 → 0.1.0-alpha.30

package/README.md

@@ -19,7 +19,7 @@ import { OTelTracingProcessor } from "operon-agents/tracing";
 
 ## Tracing
 
-Every session drives the `TracingProcessor` the `harness` hook returns as `tracing`: one
+Every session drives the `TracingProcessor` the `infrastructure` hook returns as `tracing`: one
 trace per run (a prompt and everything it triggers), spans for agents, turns, model generations,
 tool calls and sub-agents, the session id on every span as `gen_ai.conversation.id`. By default
 spans are metadata only. Pass `content: "delta"` to also record the system prompt, the messages
@@ -44,7 +44,7 @@ const tracing = new OTelTracingProcessor({ tracer: provider.getTracer("my-agent"
 
 const harness = await createLocalHarness({
   model,
-  harness: () => ({ tracing }),
+  infrastructure: () => ({ tracing }),
 });
 ```
 

package/dist/app-server/main.js

@@ -9,7 +9,7 @@
  * redirect console.log/info/debug to stderr so a stray log can never corrupt the
  * protocol stream.
  */
-import { defineModel, DiskSessionRepository } from "operon-agents-core";
+import { DiskSessionRepository } from "operon-agents-core";
 import { createHarness } from "../harness.js";
 import { nodeStreamTransport } from "./codec.js";
 import { AppServer } from "./server.js";
@@ -41,14 +41,6 @@ function parseArgs(argv) {
     }
     return out;
 }
-/** Resolve a `provider/model` id into a ChatModel (API keys come from the env). */
-function resolveModel(id) {
-    const slash = id.indexOf("/");
-    if (slash <= 0 || slash === id.length - 1) {
-        throw new Error(`invalid --model "${id}": expected "provider/model" (e.g. anthropic/claude-opus-4-...)`);
-    }
-    return defineModel({ provider: id.slice(0, slash), model: id.slice(slash + 1) });
-}
 function redirectStdoutLogsToStderr() {
     const toStderr = (...parts) => {
         process.stderr.write(`${parts.map((p) => (typeof p === "string" ? p : JSON.stringify(p))).join(" ")}\n`);
@@ -62,8 +54,7 @@ async function main() {
     const args = parseArgs(process.argv.slice(2));
     const harness = createHarness({
         model: args.model ?? "anthropic/claude-opus-4-8",
-        resolveModel,
-        ...(args.home !== undefined ? { harness: () => ({ sessionRepository: new DiskSessionRepository(args.home) }) } : {}),
+        ...(args.home !== undefined ? { infrastructure: () => ({ sessionRepository: new DiskSessionRepository(args.home) }) } : {}),
         ...(args.workdir !== undefined ? { workDir: args.workdir } : {}),
         permission: { mode: args.permission ?? "yolo" },
     });

package/dist/extensions/types.d.ts

@@ -24,7 +24,7 @@
  * `ExtensionRuntime` is the façade that hides which physical channel a decision point arrives on;
  * extension authors only ever see one `api.on(...)` table.
  */
-import type { AgentEvent, AssistantMessage, ChatModel, AgentInput, ContextBreakdown, ConversationContext, Injector, LlmRequest, Environment, Message, ModelRuntime, RunResult, SessionSummary, PendingApprovalInterrupt, SessionStore, SteerContent, SteerOptions, SteerOrigin, SteerReceipt, StepStopReason, TerminalStepStopReason, ThinkingLevel, Tool, ToolPlan, ToolResult, ToolResultContent, ToolRunContext, Usage } from "operon-agents-core";
+import type { AgentEvent, AssistantMessage, ChatModel, AgentInput, ContextBreakdown, ConversationContext, Injector, LlmRequest, Environment, Message, ModelManager, RunResult, SessionSummary, PendingApprovalInterrupt, SessionStore, SteerContent, SteerOptions, SteerOrigin, SteerReceipt, StepStopReason, TerminalStepStopReason, ThinkingLevel, Tool, ToolPlan, ToolResult, ToolResultContent, ToolRunContext, Usage } from "operon-agents-core";
 /** Per-extension key/value state, namespaced into the session store (memory without one). */
 /** A slash command an extension carries (see `ExtensionAPI.registerCommand`). The run
  *  receives only the raw argument string — an extension command closes over what it needs. */
@@ -50,11 +50,11 @@ export interface ExtensionState {
     delete(key: string): Promise<void>;
 }
 /**
- * A model provider runtime object, as the registry accepts it. Derived from `ModelRuntime`
+ * A model provider runtime object, as the registry accepts it. Derived from `ModelManager`
  * rather than imported by name: core's public `Provider` is the provider-ID STRING (a historical
  * name), while the registry wants pi's provider object.
  */
-export type ModelProvider = Parameters<ModelRuntime["models"]["setProvider"]>[0];
+export type ModelProvider = Parameters<ModelManager["models"]["setProvider"]>[0];
 /**
  * Operations that exist above the agent loop: other sessions, and the model provider registry.
  * Supplied by `Harness` when it builds an extension's capability. This is exactly why the
@@ -80,8 +80,7 @@ export interface ExtensionHost {
     listSessions(): Promise<readonly SessionSummary[]>;
     /**
      * Register (or replace) a model provider. HARNESS-GLOBAL: the model runtime is shared by
-     * every session on this harness, so this affects them all. No-op + warning when the host
-     * was built without a `modelRuntime`.
+     * every session on this harness, so this affects them all.
      */
     registerProvider(provider: ModelProvider): void;
     unregisterProvider(id: string): void;

package/dist/harness.d.ts

@@ -11,8 +11,8 @@
  * primitives for the "assemble it yourself / stateless server" path are exported from
  * `operon-agents` too.
  */
-import { type EventPublicationMode, type TelemetryService, type AgentEventListener, type AgentInput, SessionProjection, type SessionSnapshot, type SnapshotOptions, type DirectoryEntry, type ProjectionObservation, type ProjectionListener, type ApprovalRequest, type ApprovalResponse, type Capability, type InterruptAnswer, type ChatModel, ListenerSink, type PermissionManagerOptions, type PermissionMode, type PendingRunInterrupt, type QuestionRequest, type QuestionResult, type Responder, type RunHandle, type RunResult, type SessionHandle, type SessionSummary, type ListSessionsFilter, type OpenSessionOptions, type DeleteSessionOptions, type ThinkingLevel, type Tool, type SteerMessage, type SteerOptions, type SteerOrigin, type SteerReceipt, Agent, Runner, Session, McpOAuthService, SkillRegistry, type HookDef, type McpServerConfig, type McpTransportKind, type McpCredentialProvider, type PluginManager, type ApprovalRequestOptions, type Environment, type EnvironmentFactory, type SessionRepository, type ResolvedAgentProfile, type SubagentProvider } from "operon-agents-core";
-import type { SkillsService, CompactionService, BackgroundManager, McpServersHandle, GoalStore, PlanMode, Logger, ModelRuntime, TracingProcessor } from "operon-agents-core";
+import { type EventPublicationMode, type TelemetryService, type AgentEventListener, type AgentInput, SessionProjection, type SessionSnapshot, type SnapshotOptions, type DirectoryEntry, type ProjectionObservation, type ProjectionListener, type ApprovalRequest, type ApprovalResponse, type Capability, type InterruptAnswer, type ChatModel, type ModelSettings, type RunOptions, ListenerSink, type PermissionManagerOptions, type PermissionMode, type PendingRunInterrupt, type QuestionRequest, type QuestionResult, type Responder, type RunHandle, type RunResult, type SessionHandle, type SessionSummary, type ListSessionsFilter, type OpenSessionOptions, type DeleteSessionOptions, type ThinkingLevel, type Tool, type SteerMessage, type SteerOptions, type SteerOrigin, type SteerReceipt, Agent, Runner, Session, McpOAuthService, SkillRegistry, type HookDef, type McpServerConfig, type McpTransportKind, type McpCredentialProvider, type PluginManager, type ApprovalRequestOptions, type Environment, type EnvironmentFactory, type SessionRepository, type ResolvedAgentProfile, type SubagentProvider } from "operon-agents-core";
+import type { SkillsService, CompactionService, BackgroundManager, McpServersHandle, GoalStore, PlanMode, Logger, ModelManager, TracingProcessor } from "operon-agents-core";
 import { type WorkspaceMcpPool } from "./workspace-mcp.ts";
 import { HarnessExtensionManager, ServiceRegistry, type ExtensionDefinition, type ServiceOptions } from "./extensions/index.ts";
 import { type CommandResult, type TodoItem } from "operon-agents-core";
@@ -42,7 +42,7 @@ export interface DefaultCapabilitiesOptions {
      * an OAuth service, the bundle uses THOSE instead of building per-session ones. Without it
      * everything here is built per session.
      */
-    readonly shared?: HarnessParts;
+    readonly shared?: HarnessInfrastructure;
     /**
      * The session brought its own environment (`createSession({ environment })`). The shared
      * `skillRegistry` was scanned through the HARNESS's environment and does not describe this one,
@@ -57,7 +57,7 @@ export interface DefaultCapabilitiesOptions {
     /**
      * MCP servers private to the session being built — `SessionCapabilityContext.mcpServers`, i.e.
      * what the caller passed to `createSession({ mcpServers })`. They are layered OVER the
-     * harness's shared servers (`HarnessParts.mcpServers`) and over `mcpServers` above: same name, the
+     * harness's shared servers (`HarnessInfrastructure.mcpServers`) and over `mcpServers` above: same name, the
      * session's wins for this session only. Built, connected and shut down with the session.
      */
     readonly sessionMcpServers?: Record<string, McpServerConfig>;
@@ -132,21 +132,18 @@ export interface DefaultCapabilitiesOptions {
  */
 export declare function defaultCapabilities(options?: DefaultCapabilitiesOptions): Capability[];
 /**
- * The process-lived objects a harness is built on — what `HarnessOptions.harness` returns.
+ * The process-lived objects a harness is built on — what `HarnessOptions.infrastructure` returns.
  * Each one is optional; what is absent simply has no provider, and the harness falls back to
  * its own default (an in-memory repository, a silent logger, a `LocalEnvironment` per session).
  */
-export interface HarnessParts {
+export interface HarnessInfrastructure {
     readonly logger?: Logger;
     readonly sessionRepository?: SessionRepository;
-    readonly modelRuntime?: ModelRuntime;
     /** The default environment for sessions that bring none: an instance shared by all of them, or
      *  a factory called once per session. */
     readonly environment?: Environment | EnvironmentFactory;
     readonly tracing?: TracingProcessor;
-    readonly telemetry?: TelemetryService;
     readonly pluginManager?: PluginManager;
-    readonly eventPublication?: EventPublicationMode;
     /** One set of MCP connections for every session in this process. */
     readonly mcpServers?: McpServersHandle;
     /** One skill scan for every session in this process. */
@@ -159,63 +156,127 @@ export interface HarnessParts {
      */
     close?(): void | Promise<void>;
 }
-export interface HarnessOptions<TContext = unknown> {
-    /** Model for the default agent. Either a constructed `ChatModel` or an id resolved via `resolveModel`. */
-    readonly model: string | ChatModel;
-    /** Resolve string model ids (needed only if `model`/agent models are strings). */
-    readonly resolveModel?: (modelId: string) => ChatModel | Promise<ChatModel>;
-    /**
-     * The process-lived parts this harness runs on, built once. Everything a session needs that is
-     * NOT per-session lives here: the repository (disk locally, Pg/Redis on a server; in-memory
-     * when absent), the logger, the model runtime, the default environment, one set of MCP
-     * connections, one skill scan. Runs before the by-value extensions' `harness` halves, so they
-     * can consume what it returns.
-     *
-     * There is no tier between this and a session. A shared object is shared by the WHOLE process
-     * or it is built per session — nothing is shared by "the sessions in one directory".
+/** The settings every run on one session carries. */
+type SessionRunOverrides<TContext> = Pick<RunOptions<TContext>, "maxTurns" | "subagentProvider" | "workflowTool" | "maxConcurrentSubagents">;
+/**
+ * What a harness sets for every session and a session may set for itself. A value given when a
+ * session is opened replaces the harness's, whole; nothing merges.
+ */
+export interface SessionSettings<TContext = unknown> {
+    /**
+     * This session's model: a `provider/model` id, or a built `ChatModel`, which is how one session
+     * gets its own API key. Applied like `setModel` at open, so it also beats `agent`'s own model.
+     * Not persisted: a resume passes it again or runs on the harness's model.
      */
-    readonly harness?: () => HarnessParts | Promise<HarnessParts>;
+    readonly model?: string | ChatModel;
     /**
-     * Session-tier composition: called once per session being opened. Return its capabilities.
-     * Defaults to `defaultCapabilities()`. Always called fresh per session, so per-session state
-     * (goal/plan/todo/background/skills/mcp) is isolated by construction.
+     * How the default agent's model should behave: `maxTokens`, `temperature`, `reasoning` and so on.
+     * Ignored when `agent` is given, whose own `modelSettings` apply. Timeouts and retries are
+     * `connection` on the provider's registration.
      */
-    readonly session?: (ctx: SessionCapabilityContext) => readonly Capability[] | Promise<readonly Capability[]>;
-    /** Default working directory for new sessions. Defaults to `process.cwd()`. */
-    readonly workDir?: string;
+    readonly modelSettings?: ModelSettings;
+    /**
+     * The agent for new sessions. Provide a complete `Agent`, or omit it to run the builtin default
+     * profile (`DEFAULT_AGENT_PROFILES.agent`) rendered as an agent — there is no piecemeal middle
+     * ground.
+     */
+    readonly agent?: Agent<TContext>;
+    /**
+     * Host application context for sessions. It is runtime-only: never serialized into the log or
+     * SessionStore, so a process reopening a session provides it again with
+     * `resumeSession(id, { context })`.
+     */
+    readonly context?: TContext;
+    /**
+     * Concrete tool palette the default profile's tool NAMES resolve against (and the subagent palette).
+     * Defaults to `filesystemTools()` plus `askUserQuestionTool`; capability tools (goal/plan/todo/…) are
+     * injected at runtime, so they need not appear here. Ignored when `agent` is given — a complete agent
+     * carries its own tools.
+     */
+    readonly tools?: readonly Tool[];
+    /**
+     * Extra guidance appended to the default agent's system prompt (the profile's `roleAdditional` slot,
+     * rendered after its own prompt). This LAYERS on the default profile — it does not replace it; for a
+     * wholly different prompt, pass a complete `agent`. Ignored when `agent` is given.
+     */
+    readonly appendSystemPrompt?: string;
+    /**
+     * Subagent fleet the `Agent` / `Workflow` tools spawn by type. Defaults to the builtin
+     * `coder` / `explore` / `plan` profiles (each inherits the session model; their tools resolve
+     * against the default agent's toolset), so orchestration works out of the box. Pass your own
+     * provider to override, or `null` to disable subagents entirely — which also hides the
+     * Agent/Workflow tools, since there is nothing for them to spawn.
+     */
+    readonly subagentProvider?: SubagentProvider<TContext> | null;
+    /**
+     * Extra subagent profiles merged into the builtin `coder`/`explore`/`plan` fleet. The SOURCE is
+     * the composition root's concern — disk (`loadAgentProfiles`) locally, external on a server —
+     * but the merge/tool-wiring is identical. Ignored when `subagentProvider` is given.
+     */
+    readonly extraSubagentProfiles?: Record<string, ResolvedAgentProfile>;
+    /**
+     * Expose the builtin `Workflow` tool (default true).
+     *
+     * The narrow version of the switch above: use it when the host has its own
+     * workflow orchestration and two overlapping tools would leave the model
+     * guessing. Subagents and the `Agent` tool are unaffected — unlike
+     * `subagentProvider: null`, which necessarily takes both tools with it.
+     */
+    readonly workflowTool?: boolean;
     /**
      * Cap on subagents running concurrently from one session's root frame. Defaults to the same
      * bound the `Workflow` tool uses, so a batch of `Agent` spawns cannot fan out further than a
      * workflow would. Nested spawns are exempt by design (they would deadlock a shared pool).
      */
     readonly maxConcurrentSubagents?: number;
+    /** Permission config. Defaults to `{ mode: "yolo" }`. */
+    readonly permission?: PermissionManagerOptions;
     /** Event durability policy. Defaults to `immediate` for low-latency local applications.
      *  Managed servers override each opened session to `committed`. */
     readonly eventPublication?: EventPublicationMode;
+    /** Turn cap for each run. */
+    readonly maxTurns?: number;
     /**
-     * Product telemetry (docs/telemetry.md). Process-lifetime: create ONE service, attach the
-     * appenders once, pass the same instance to every harness. Absent = nothing is counted.
-     * The harness never shuts it down; the product does, before exit.
+     * Step-per-turn cap. Carried on the default agent (the Runner reads the agent's value first),
+     * so it is ignored when `agent` is given.
      */
-    readonly telemetry?: TelemetryService;
-    /**
-     * Extra subagent profiles merged into the builtin `coder`/`explore`/`plan` fleet. The SOURCE is
-     * the composition root's concern — disk (`loadAgentProfiles`) locally, external on a server —
-     * but the merge/tool-wiring is identical. Ignored when `subagentProvider` is given.
+    readonly maxStepsPerTurn?: number;
+}
+export interface HarnessOptions<TContext = unknown> extends SessionSettings<TContext> {
+    /** Model for sessions that name none: a `provider/model` id looked up in {@link modelManager}. */
+    readonly model: string;
+    /**
+     * The one model manager this harness runs on: what every string model id resolves against.
+     * Defaults to a fresh `createModelManager()`. Pass one only for what cannot be changed later,
+     * such as a custom credential store. Add providers in place: `harness.modelManager.register()` for
+     * plain configuration, `harness.modelManager.models.setProvider()` for one built with `createProvider`.
+     */
+    readonly modelManager?: ModelManager;
+    /**
+     * The process-lived infrastructure this harness runs on, built once. Everything a session needs
+     * that is NOT per-session lives here: the repository (disk locally, Pg/Redis on a server;
+     * in-memory when absent), the logger, the default environment, one set of MCP connections, one
+     * skill scan. Runs before the by-value extensions' `harness` halves, so they can consume what it
+     * returns.
+     *
+     * There is no tier between this and a session. A shared object is shared by the WHOLE process
+     * or it is built per session — nothing is shared by "the sessions in one directory".
      */
-    readonly extraSubagentProfiles?: Record<string, ResolvedAgentProfile>;
+    readonly infrastructure?: () => HarnessInfrastructure | Promise<HarnessInfrastructure>;
     /**
-     * The agent for new sessions. Provide a complete `Agent`, or omit it to run the builtin default
-     * profile (`DEFAULT_AGENT_PROFILES.agent`) rendered as an agent — there is no piecemeal middle
-     * ground. Per-session overrides go through `createSession({ agent })`.
+     * Session-tier composition: called once per session being opened. Return its capabilities.
+     * Defaults to `defaultCapabilities()`. Always called fresh per session, so per-session state
+     * (goal/plan/todo/background/skills/mcp) is isolated by construction.
      */
-    readonly agent?: Agent<TContext>;
+    readonly sessionCapabilities?: (ctx: SessionCapabilityContext) => readonly Capability[] | Promise<readonly Capability[]>;
+    /** Default working directory for new sessions. Defaults to `process.cwd()`. */
+    readonly workDir?: string;
     /**
-     * Default host application context for sessions. It is runtime-only: never serialized into
-     * the log or SessionStore. Override per session with `createSession({ context })` or provide it
-     * again when reopening a process with `resumeSession(id, { context })`.
+     * Product telemetry (docs/telemetry.md). Process-lifetime: create ONE service, attach the
+     * appenders once, pass the same instance to every harness. Absent = nothing is counted.
+     * The harness never shuts it down; the product does, before exit.
      */
-    readonly context?: TContext;
+    readonly telemetry?: TelemetryService;
     /**
      * Process-level shared services BY NAME, registered into the harness scope at construction
      * (extension services are the one string-keyed corner: an extension is loaded by its id and
@@ -244,36 +305,6 @@ export interface HarnessOptions<TContext = unknown> {
      * `undefined`). Kept outside the code folders so an update never touches state.
      */
     readonly extensionDataDir?: string;
-    /**
-     * Concrete tool palette the default profile's tool NAMES resolve against (and the subagent palette).
-     * Defaults to `filesystemTools()` plus `askUserQuestionTool`; capability tools (goal/plan/todo/…) are
-     * injected at runtime, so they need not appear here. Ignored when `agent` is given — a complete agent
-     * carries its own tools.
-     */
-    readonly tools?: readonly Tool[];
-    /**
-     * Extra guidance appended to the default agent's system prompt (the profile's `roleAdditional` slot,
-     * rendered after its own prompt). This LAYERS on the default profile — it does not replace it; for a
-     * wholly different prompt, pass a complete `agent`. Ignored when `agent` is given.
-     */
-    readonly appendSystemPrompt?: string;
-    /**
-     * Subagent fleet the `Agent` / `Workflow` tools spawn by type. Defaults to the builtin
-     * `coder` / `explore` / `plan` profiles (each inherits the session model; their tools resolve
-     * against the default agent's toolset), so orchestration works out of the box. Pass your own
-     * provider to override, or `null` to disable subagents entirely — which also hides the
-     * Agent/Workflow tools, since there is nothing for them to spawn.
-     */
-    readonly subagentProvider?: SubagentProvider<TContext> | null;
-    /**
-     * Expose the builtin `Workflow` tool (default true).
-     *
-     * The narrow version of the switch above: use it when the host has its own
-     * workflow orchestration and two overlapping tools would leave the model
-     * guessing. Subagents and the `Agent` tool are unaffected — unlike
-     * `subagentProvider: null`, which necessarily takes both tools with it.
-     */
-    readonly workflowTool?: boolean;
     /**
      * Programmatic runtime extensions, registered once here — the by-value twin of `extensionDir`.
      * Every definition's `session` runs in every session; a session varies that with
@@ -287,10 +318,6 @@ export interface HarnessOptions<TContext = unknown> {
      * are skills/MCP/hooks metadata, extensions are trusted host code.
      */
     readonly extensions?: readonly ExtensionDefinition[];
-    /** Permission config. Defaults to `{ mode: "yolo" }`. */
-    readonly permission?: PermissionManagerOptions;
-    readonly maxTurns?: number;
-    readonly maxStepsPerTurn?: number;
 }
 /**
  * What a capability factory is told about the session it is building for.
@@ -328,13 +355,9 @@ export interface SessionCapabilityContext {
  * Each one is already a session-level input inside the engine; the harness was
  * simply passing its own value straight through.
  */
-interface OpenSessionOptionsBase<TContext = unknown> {
-    /** Override the agent for this session only. */
-    readonly agent?: Agent<TContext>;
+interface OpenSessionOptionsBase<TContext = unknown> extends SessionSettings<TContext> {
     /** Override the execution environment for this session only. Lifecycle remains host-owned. */
     readonly environment?: Environment | EnvironmentFactory;
-    /** Runtime-only application context for this session. Overrides `HarnessOptions.context`. */
-    readonly context?: TContext;
     /**
      * MCP servers scoped to this session, surfaced to the capability factory via
      * {@link SessionCapabilityContext}. Merge policy is the factory's call — the
@@ -361,24 +384,6 @@ interface OpenSessionOptionsBase<TContext = unknown> {
      * This is the per-session knob: definitions themselves are registered once, on the harness.
      */
     readonly params?: Record<string, unknown>;
-    /** Permission config for this session. Overrides `HarnessOptions.permission`. */
-    readonly permission?: PermissionManagerOptions;
-    /** Override this session's event durability policy. */
-    readonly eventPublication?: EventPublicationMode;
-    /**
-     * Extra system-prompt text for this session's default agent. Overrides
-     * `HarnessOptions.appendSystemPrompt`. Ignored when `agent` is given, since that
-     * replaces the default agent outright.
-     */
-    readonly appendSystemPrompt?: string;
-    /** Turn cap for this session's runs. Overrides `HarnessOptions.maxTurns`. */
-    readonly maxTurns?: number;
-    /**
-     * Step-per-turn cap for this session. Overrides `HarnessOptions.maxStepsPerTurn`.
-     * Carried on the session's default agent (the Runner reads the agent's value
-     * first), so it is ignored when `agent` is given.
-     */
-    readonly maxStepsPerTurn?: number;
 }
 export interface CreateSessionOptions<TContext = unknown> extends OpenSessionOptionsBase<TContext> {
     readonly id?: string;
@@ -457,8 +462,7 @@ export declare class HarnessSession<TContext = unknown> {
     private readonly closingNotified;
     /** A wake is already scheduled on the microtask queue; more enqueues fold into it. */
     private wakeScheduled;
-    /** Per-session turn cap; the Runner's own config is the fallback. */
-    private readonly maxTurns;
+    private readonly runOverrides;
     /** Builds the capability an extension attached to THIS session runs as — bound to the
      *  session's harness reach and its per-session params. */
     private readonly mountExtension;
@@ -471,7 +475,7 @@ export declare class HarnessSession<TContext = unknown> {
         projection: SessionProjection;
         workDir: string;
         context?: TContext;
-        maxTurns?: number;
+        runOverrides: SessionRunOverrides<TContext>;
         interrupted?: boolean;
         mountExtension: (definition: ExtensionDefinition) => Capability;
         onClosed: (id: string) => void | Promise<void>;
@@ -493,8 +497,6 @@ export declare class HarnessSession<TContext = unknown> {
      * Re-checked in a loop: a new hold can land between a release and this task resuming.
      */
     private parkAtGate;
-    /** Run options every run on this session carries — currently the session's turn cap. */
-    private get runOverrides();
     /** Current runtime-only application context supplied to Agent callbacks. */
     get context(): TContext | undefined;
     get status(): HarnessSessionStatus;
@@ -683,14 +685,19 @@ export declare class Harness<TContext = unknown> {
     private readonly runner;
     /** Concrete tools the default profile's tool NAMES resolve against (keyed by schema name). */
     private readonly toolPalette;
+    private readonly agentTools;
+    private readonly defaultSubagents;
     private readonly activeSessions;
     /** Opens in flight by session id (`resumeSession`): concurrent callers share ONE open — the
      *  whole of it, reconcile and failure cleanup included — instead of each building an instance. */
     private readonly opening;
     /** The one close in flight (or finished): every `close()` call returns THIS promise. */
     private closing;
-    /** The process-lived objects this harness runs on (`HarnessOptions.harness`), plus defaults. */
-    private parts;
+    /** The one model manager of this harness. Edit its providers in place; it is never swapped. */
+    readonly modelManager: ModelManager;
+    private readonly resolveModel;
+    /** The process-lived objects this harness runs on (`HarnessOptions.infrastructure`), plus defaults. */
+    private infrastructure;
     /** Process-level extension services by name (a facade over `scope`). The host replaces
      *  providers here (`services.replace`); sessions only ever see handles (`ctx.shared`, `ctx.services`). */
     readonly services: ServiceRegistry;
@@ -717,12 +724,12 @@ export declare class Harness<TContext = unknown> {
     private runningCreate;
     constructor(options: HarnessOptions<TContext>);
     /**
-     * Which session-facing parts the `harness` hook built for the whole process — what a
+     * Which session-facing parts the `infrastructure` hook built for the whole process — what a
      * multi-tenant host must not have, since every session on the process would share them.
      * Infrastructure (repository, logger, model runtime) is not listed: sharing it is the point.
      */
     processSharedParts(): Promise<readonly ("mcpServers" | "oauthService" | "skillRegistry")[]>;
-    /** The session repository, once the `harness` hook has had its say. */
+    /** The session repository, once the `infrastructure` hook has had its say. */
     private repository;
     /** The fallback repository, built once so two opens share one in-memory store. */
     private memoryRepository;
@@ -757,6 +764,13 @@ export declare class Harness<TContext = unknown> {
      * prompts stay isolated without coupling Agent lifetime to environment lifetime.
      */
     private buildDefaultAgent;
+    /**
+     * The Agent/Workflow tools only appear when a run has subagents to spawn. The fleet defaults to
+     * the builtin coder/explore/plan profiles so orchestration works out of the box; an explicit
+     * provider overrides it, and `null` opts out (hiding those tools).
+     */
+    private subagentProviderFor;
+    private runOverridesFor;
     get sessions(): ReadonlyMap<string, HarnessSession<TContext>>;
     createSession(opts?: CreateSessionOptions<TContext>): Promise<HarnessSession<TContext>>;
     /**

package/dist/harness.js

@@ -11,7 +11,7 @@
  * primitives for the "assemble it yourself / stateless server" path are exported from
  * `operon-agents` too.
  */
-import { readSessionTails, SessionProjection, ListenerSink, recoverOrphanedTurns, Agent, buildAgentFromProfile, INTERRUPTION_STATE_KEY, flattenPendingInterrupts, parseInterruptionState, Runner, Session, emptyUsage, isGuardrailTripwireError, askUserQuestionTool, backgroundCapability, compactionCapability, filesystemTools, goalCapability, LocalEnvironment, McpOAuthService, MemorySessionRepository, SessionRepositoryNotFoundError, planCapability, skillsCapability, SkillRegistry, mcpServersCapability, pluginsCapability, userHooksCapability, taskCapability, workflowCapability, DEFAULT_AGENT_PROFILES, DEFAULT_AGENT_PROFILE_NAME, DEFAULT_SUBAGENT_NAMES, profileSubagentProvider, DEFAULT_ADDRESS, envLogger, noopLogger, } from "operon-agents-core";
+import { readSessionTails, SessionProjection, ListenerSink, recoverOrphanedTurns, Agent, buildAgentFromProfile, INTERRUPTION_STATE_KEY, flattenPendingInterrupts, parseInterruptionState, Runner, Session, emptyUsage, isGuardrailTripwireError, askUserQuestionTool, createModelManager, backgroundCapability, compactionCapability, filesystemTools, goalCapability, LocalEnvironment, McpOAuthService, MemorySessionRepository, SessionRepositoryNotFoundError, planCapability, skillsCapability, SkillRegistry, mcpServersCapability, pluginsCapability, userHooksCapability, taskCapability, workflowCapability, DEFAULT_AGENT_PROFILES, DEFAULT_AGENT_PROFILE_NAME, DEFAULT_SUBAGENT_NAMES, profileSubagentProvider, DEFAULT_ADDRESS, envLogger, noopLogger, } from "operon-agents-core";
 import { mkdirSync } from "node:fs";
 import { workspaceMcpCapability } from "./workspace-mcp.js";
 import { join } from "node:path";
@@ -138,9 +138,12 @@ function defaultSubagentProvider(agentTools, resolveModel, extraProfiles = {}) {
     return profileSubagentProvider(profiles, {
         only,
         tools,
-        ...(resolveModel !== undefined ? { resolveModel } : {}),
+        resolveModel,
     });
 }
+function toolPaletteOf(tools) {
+    return Object.fromEntries(tools.map((tool) => [tool.schema.name, tool]));
+}
 /** A `Responder` whose approval/question handlers can be swapped at runtime (last-wins). */
 class MutableResponder {
     approvalHandler;
@@ -215,8 +218,7 @@ export class HarnessSession {
     });
     /** A wake is already scheduled on the microtask queue; more enqueues fold into it. */
     wakeScheduled = false;
-    /** Per-session turn cap; the Runner's own config is the fallback. */
-    maxTurns;
+    runOverrides;
     /** Builds the capability an extension attached to THIS session runs as — bound to the
      *  session's harness reach and its per-session params. */
     mountExtension;
@@ -230,7 +232,7 @@ export class HarnessSession {
         this.events = args.events;
         this.responder = args.responder;
         this.runContext = args.context;
-        this.maxTurns = args.maxTurns;
+        this.runOverrides = args.runOverrides;
         this.lastRunInterrupted = args.interrupted ?? false;
         this.onClosed = args.onClosed;
         this.mountExtension = args.mountExtension;
@@ -291,10 +293,6 @@ export class HarnessSession {
                 throw new Error(`session "${this.id}" is closed`);
         }
     }
-    /** Run options every run on this session carries — currently the session's turn cap. */
-    get runOverrides() {
-        return this.maxTurns !== undefined ? { maxTurns: this.maxTurns } : {};
-    }
     /** Current runtime-only application context supplied to Agent callbacks. */
     get context() {
         return this.runContext;
@@ -836,14 +834,19 @@ export class Harness {
     runner;
     /** Concrete tools the default profile's tool NAMES resolve against (keyed by schema name). */
     toolPalette;
+    agentTools;
+    defaultSubagents;
     activeSessions = new Map();
     /** Opens in flight by session id (`resumeSession`): concurrent callers share ONE open — the
      *  whole of it, reconcile and failure cleanup included — instead of each building an instance. */
     opening = new Map();
     /** The one close in flight (or finished): every `close()` call returns THIS promise. */
     closing;
-    /** The process-lived objects this harness runs on (`HarnessOptions.harness`), plus defaults. */
-    parts = {};
+    /** The one model manager of this harness. Edit its providers in place; it is never swapped. */
+    modelManager;
+    resolveModel;
+    /** The process-lived objects this harness runs on (`HarnessOptions.infrastructure`), plus defaults. */
+    infrastructure = {};
     /** Process-level extension services by name (a facade over `scope`). The host replaces
      *  providers here (`services.replace`); sessions only ever see handles (`ctx.shared`, `ctx.services`). */
     services;
@@ -870,22 +873,16 @@ export class Harness {
     runningCreate;
     constructor(options) {
         this.options = options;
+        this.modelManager = options.modelManager ?? createModelManager();
+        this.resolveModel = (id) => this.modelManager.resolve(id);
         this.services = new ServiceRegistry();
-        const agentTools = options.tools ?? [...filesystemTools(), askUserQuestionTool];
-        this.toolPalette = Object.fromEntries(agentTools.map((tool) => [tool.schema.name, tool]));
-        // The Agent/Workflow tools only appear when the run has subagents to spawn. Default the fleet
-        // to the builtin coder/explore/plan profiles so orchestration works out of the box; an explicit
-        // provider overrides it, and `null` opts out (hiding those tools).
-        const subagentProvider = options.subagentProvider === null
-            ? undefined
-            : options.subagentProvider ?? defaultSubagentProvider(agentTools, options.resolveModel, options.extraSubagentProfiles);
+        this.agentTools = options.tools ?? [...filesystemTools(), askUserQuestionTool];
+        this.toolPalette = toolPaletteOf(this.agentTools);
+        this.defaultSubagents = defaultSubagentProvider(this.agentTools, this.resolveModel, options.extraSubagentProfiles);
         this.runner = new Runner({
-            resolveModel: options.resolveModel,
-            subagentProvider,
-            ...(options.workflowTool !== undefined ? { workflowTool: options.workflowTool } : {}),
+            resolveModel: this.resolveModel,
             maxTurns: options.maxTurns,
             maxStepsPerTurn: options.maxStepsPerTurn,
-            ...(options.maxConcurrentSubagents !== undefined ? { maxConcurrentSubagents: options.maxConcurrentSubagents } : {}),
         });
         this.dataRoot = options.extensionDataDir ?? (options.extensionDir !== undefined ? join(options.extensionDir, ".data") : undefined);
         this.extensions = options.extensionDir === undefined
@@ -920,14 +917,9 @@ export class Harness {
         // The host's process-tier registrations come first (extension `harness` halves may consume
         // them); a synchronous hook keeps the whole chain synchronous, so a synchronous extension's
         // service exists the moment `createHarness` returns.
-        const composed = options.harness?.();
+        const composed = options.infrastructure?.();
         const absorb = (parts) => {
-            this.parts = {
-                ...(parts ?? {}),
-                // Explicit options win over what the preset built, and both win over the defaults below.
-                ...(options.telemetry !== undefined ? { telemetry: options.telemetry } : {}),
-                ...(options.eventPublication !== undefined ? { eventPublication: options.eventPublication } : {}),
-            };
+            this.infrastructure = parts ?? {};
         };
         this.sharedReady = composed instanceof Promise
             ? composed.then((parts) => {
@@ -939,33 +931,33 @@ export class Harness {
         this.sharedReady.catch(() => undefined);
     }
     /**
-     * Which session-facing parts the `harness` hook built for the whole process — what a
+     * Which session-facing parts the `infrastructure` hook built for the whole process — what a
      * multi-tenant host must not have, since every session on the process would share them.
      * Infrastructure (repository, logger, model runtime) is not listed: sharing it is the point.
      */
     async processSharedParts() {
         await this.sharedReady;
         const parts = [];
-        if (this.parts.mcpServers !== undefined)
+        if (this.infrastructure.mcpServers !== undefined)
             parts.push("mcpServers");
-        if (this.parts.oauthService !== undefined)
+        if (this.infrastructure.oauthService !== undefined)
             parts.push("oauthService");
-        if (this.parts.skillRegistry !== undefined)
+        if (this.infrastructure.skillRegistry !== undefined)
             parts.push("skillRegistry");
         return parts;
     }
-    /** The session repository, once the `harness` hook has had its say. */
+    /** The session repository, once the `infrastructure` hook has had its say. */
     async repository() {
         await this.sharedReady;
         this.memoryRepository ??= new MemorySessionRepository();
-        return this.parts.sessionRepository ?? this.memoryRepository;
+        return this.infrastructure.sessionRepository ?? this.memoryRepository;
     }
     /** The fallback repository, built once so two opens share one in-memory store. */
     memoryRepository;
     /** The harness logger: the preset's, else the `AGENTS_LOG` env logger, else silent. */
     get logger() {
         this.defaultLogger ??= envLogger() ?? noopLogger;
-        return this.parts.logger ?? this.defaultLogger;
+        return this.infrastructure.logger ?? this.defaultLogger;
     }
     defaultLogger;
     /**
@@ -1061,17 +1053,43 @@ export class Harness {
      * resolves the current frame's environment + cwd through the Session cache, so root/subagent/worktree
      * prompts stay isolated without coupling Agent lifetime to environment lifetime.
      */
-    buildDefaultAgent(appendSystemPrompt, maxStepsPerTurn) {
-        const additional = appendSystemPrompt ?? this.options.appendSystemPrompt;
-        const steps = maxStepsPerTurn ?? this.options.maxStepsPerTurn;
+    buildDefaultAgent(opts) {
+        const additional = opts.appendSystemPrompt ?? this.options.appendSystemPrompt;
+        const steps = opts.maxStepsPerTurn ?? this.options.maxStepsPerTurn;
+        const modelSettings = opts.modelSettings ?? this.options.modelSettings;
         return buildAgentFromProfile(DEFAULT_AGENT_PROFILES[DEFAULT_AGENT_PROFILE_NAME], {
-            tools: this.toolPalette,
+            tools: opts.tools === undefined ? this.toolPalette : toolPaletteOf(opts.tools),
             model: this.options.model,
             ...(additional !== undefined ? { roleAdditional: additional } : {}),
             ...(steps !== undefined ? { maxStepsPerTurn: steps } : {}),
-            ...(this.options.resolveModel !== undefined ? { resolveModel: this.options.resolveModel } : {}),
+            ...(modelSettings !== undefined ? { modelSettings } : {}),
+            resolveModel: this.resolveModel,
         });
     }
+    /**
+     * The Agent/Workflow tools only appear when a run has subagents to spawn. The fleet defaults to
+     * the builtin coder/explore/plan profiles so orchestration works out of the box; an explicit
+     * provider overrides it, and `null` opts out (hiding those tools).
+     */
+    subagentProviderFor(opts) {
+        const chosen = opts.subagentProvider !== undefined ? opts.subagentProvider : this.options.subagentProvider;
+        if (chosen !== undefined)
+            return chosen;
+        if (opts.tools === undefined && opts.extraSubagentProfiles === undefined)
+            return this.defaultSubagents;
+        return defaultSubagentProvider(opts.tools ?? this.agentTools, this.resolveModel, opts.extraSubagentProfiles ?? this.options.extraSubagentProfiles);
+    }
+    runOverridesFor(opts) {
+        const maxTurns = opts.maxTurns ?? this.options.maxTurns;
+        const workflowTool = opts.workflowTool ?? this.options.workflowTool;
+        const maxConcurrentSubagents = opts.maxConcurrentSubagents ?? this.options.maxConcurrentSubagents;
+        return {
+            subagentProvider: this.subagentProviderFor(opts),
+            ...(maxTurns !== undefined ? { maxTurns } : {}),
+            ...(workflowTool !== undefined ? { workflowTool } : {}),
+            ...(maxConcurrentSubagents !== undefined ? { maxConcurrentSubagents } : {}),
+        };
+    }
     get sessions() {
         return this.activeSessions;
     }
@@ -1243,7 +1261,7 @@ export class Harness {
         // Last: the process-shared objects the preset opened (MCP connections, handles). Every
         // session is closed by now, so nothing is still reading them.
         try {
-            await this.parts.close?.();
+            await this.infrastructure.close?.();
         }
         catch (error) {
             this.logger.log("warn", "harness parts close failed", { error: error instanceof Error ? error.message : String(error) });
@@ -1415,10 +1433,10 @@ export class Harness {
     async resolveCapabilities(ctx, params = {}) {
         // A session on its own environment (a sandbox) does not get the process's MCP connections or
         // skill scan: both describe the HARNESS's machine, not the one this session's tools run on.
-        const base = this.options.session !== undefined
-            ? await this.options.session(ctx)
+        const base = this.options.sessionCapabilities !== undefined
+            ? await this.options.sessionCapabilities(ctx)
             : defaultCapabilities({
-                shared: this.parts,
+                shared: this.infrastructure,
                 ownEnvironment: ctx.ownEnvironment,
                 strictIsolation: ctx.strictIsolation,
                 ...(ctx.mcpServers !== undefined ? { sessionMcpServers: ctx.mcpServers } : {}),
@@ -1449,7 +1467,7 @@ export class Harness {
      */
     extensionHost(sessionId) {
         const self = this;
-        const runtime = this.parts.modelRuntime;
+        const runtime = this.modelManager;
         return {
             sessionId,
             newSession: (options) => self.createSession({ ...(options?.title !== undefined ? { title: options.title } : {}) }),
@@ -1457,13 +1475,9 @@ export class Harness {
             openSession: (id) => self.resumeSession(id),
             listSessions: () => self.listSessions(),
             registerProvider: (provider) => {
-                if (!runtime)
-                    throw new Error("registerProvider() requires the harness to be built with a `modelRuntime`");
                 runtime.models.setProvider(provider);
             },
             unregisterProvider: (id) => {
-                if (!runtime)
-                    throw new Error("unregisterProvider() requires the harness to be built with a `modelRuntime`");
                 runtime.models.deleteProvider(id);
             },
             services: {
@@ -1502,7 +1516,7 @@ export class Harness {
             const responder = new MutableResponder();
             // Environment: this call's override → the harness's default → a LocalEnvironment at the
             // session's own workDir. The session only OPERATES a caller-supplied environment.
-            const environment = opts.environment ?? this.parts.environment ?? new LocalEnvironment(workDir);
+            const environment = opts.environment ?? this.infrastructure.environment ?? new LocalEnvironment(workDir);
             // ONE open-time log read, shared: every shard from its newest checkpoint on (each
             // checkpoint carries the history and lifecycle before it). The projection seeds from it,
             // and Session.open receives it as `preloadedLog` so its capability restore + context
@@ -1541,16 +1555,18 @@ export class Harness {
                 responder,
                 environment,
                 permissionOptions: opts.permission ?? this.options.permission ?? { mode: "yolo" },
-                ...(this.parts.logger !== undefined ? { logger: this.parts.logger } : {}),
-                ...(this.parts.tracing !== undefined ? { tracing: this.parts.tracing } : {}),
-                ...(this.parts.telemetry !== undefined ? { telemetry: this.parts.telemetry } : {}),
-                ...(opts.eventPublication ?? this.parts.eventPublication) !== undefined
-                    ? { eventPublication: (opts.eventPublication ?? this.parts.eventPublication) }
+                ...(this.infrastructure.logger !== undefined ? { logger: this.infrastructure.logger } : {}),
+                ...(this.infrastructure.tracing !== undefined ? { tracing: this.infrastructure.tracing } : {}),
+                ...(this.options.telemetry !== undefined ? { telemetry: this.options.telemetry } : {}),
+                ...(opts.eventPublication ?? this.options.eventPublication) !== undefined
+                    ? { eventPublication: (opts.eventPublication ?? this.options.eventPublication) }
                     : {},
             });
             const agent = opts.agent ??
                 this.options.agent ??
-                (await this.buildDefaultAgent(opts.appendSystemPrompt, opts.maxStepsPerTurn));
+                (await this.buildDefaultAgent(opts));
+            if (opts.model !== undefined)
+                core.setModel(opts.model);
             const session = new HarnessSession({
                 core,
                 // The two caps land in different places: maxStepsPerTurn is an Agent property
@@ -1562,9 +1578,7 @@ export class Harness {
                 projection,
                 workDir,
                 context: this.contextFor(opts),
-                ...(opts.maxTurns ?? this.options.maxTurns) !== undefined
-                    ? { maxTurns: opts.maxTurns ?? this.options.maxTurns }
-                    : {},
+                runOverrides: this.runOverridesFor(opts),
                 interrupted,
                 mountExtension: (definition) => {
                     if (params?.[definition.id] === false) {
@@ -1597,7 +1611,7 @@ export class Harness {
      * throws (a cleanup failure is logged, never allowed to mask the open's own error).
      */
     async rollbackOpen(id, built, cause) {
-        const logger = this.parts.logger;
+        const logger = this.infrastructure.logger;
         const attempt = async (step, run) => {
             try {
                 await run();

package/dist/local.d.ts

@@ -1,16 +1,16 @@
-import type { ModelRuntime } from "operon-agents-core";
+import type { ModelManager } from "operon-agents-core";
 import { type HookDef, type Logger, type McpServerConfig, type PluginManager } from "operon-agents-core";
 import { type Harness, type HarnessOptions } from "./harness.ts";
 export interface LocalDeploymentOptions<TContext = unknown> extends HarnessOptions<TContext> {
     /**
      * App home root — sessions (`<homeDir>/sessions`), MCP creds, logs, and disk-discovered agent
      * profiles all live under it. Defaults to `~/.agents`. (`homeDir` is a local-deployment concept;
-     * the harness itself only knows `HarnessParts.sessionRepository`.)
+     * the harness itself only knows `HarnessInfrastructure.sessionRepository`.)
      */
     readonly homeDir?: string;
     /** MCP servers to expose, shared by every session of the harness. */
     readonly mcpServers?: Record<string, McpServerConfig>;
-    /** Installed-plugin manager, if any. Loaded once here, then handed out as `HarnessParts.pluginManager`. */
+    /** Installed-plugin manager, if any. Loaded once here, then handed out as `HarnessInfrastructure.pluginManager`. */
     readonly pluginManager?: PluginManager;
     /** Shell hooks from config (`config.hooks`), projected as HookDefs. */
     readonly hooks?: readonly HookDef[];
@@ -20,14 +20,9 @@ export interface LocalDeploymentOptions<TContext = unknown> extends HarnessOptio
     readonly logger?: Logger;
     /** Context budget for the default compaction capability. */
     readonly maxContextTokens?: number;
-    /**
-     * The model runtime this harness resolves providers through. Pass the same one the host used to
-     * build its `ChatModel` (see `createModelRuntimeFromConfig`) when a model lives on a configured
-     * endpoint — otherwise the two registries disagree about what exists. Omitted, the harness builds
-     * one from `<homeDir>/providers.toml` itself.
-     */
-    readonly modelRuntime?: ModelRuntime;
-    /** Skip reading `<homeDir>/providers.toml` entirely. Ignored when `modelRuntime` is given. */
+    /** {@link HarnessOptions.modelManager}. Omitted, it is built from `<homeDir>/providers.toml`. */
+    readonly modelManager?: ModelManager;
+    /** Skip reading `<homeDir>/providers.toml` entirely. Ignored when `modelManager` is given. */
     readonly loadConfiguredProviders?: boolean;
 }
 /** Build `HarnessOptions` wired for a local, single-environment deployment. */

package/dist/local.js

@@ -4,7 +4,7 @@
  * file log, file-backed MCP credentials, disk-discovered agent profiles, and the cron extension.
  *
  * It is a PRESET: pure data in (`LocalDeploymentOptions`), the three composition hooks out.
- * The `harness` hook registers the process-lived objects on the harness scope; the `session`
+ * The `harness` hook registers the process-lived objects on the harness scope; the `sessionCapabilities`
  * hook builds each session's capability set. A hosted deployment writes its own preset the same
  * way (see `examples/managed-agents`) — there is still no "mode" inside the engine
  * (Architecture Invariant 7): this file only picks backends, and returns plain `HarnessOptions`
@@ -12,14 +12,14 @@
  */
 import { homedir } from "node:os";
 import { cronExtension } from "./cron/index.js";
-import { createModelRuntimeFromConfig } from "./providers.js";
+import { createModelManagerFromConfig } from "./providers.js";
 import { join, resolve } from "node:path";
 import { DiskSessionRepository, LocalEnvironment, McpOAuthService, RotatingFileSink, SkillRegistry, createMcpServers, loadSkillRoots, loadAgentProfiles, resolveGlobalLogPath, sinkLogger, } from "operon-agents-core";
 import { createHarness, defaultCapabilities, } from "./harness.js";
 /** Build `HarnessOptions` wired for a local, single-environment deployment. */
 export async function localHarnessOptions(options) {
-    const { homeDir: home, mcpServers, pluginManager, hooks, loadDiskProfiles, logger, maxContextTokens, modelRuntime, loadConfiguredProviders, harness, session, extensions, ...engine } = options;
-    // Filled by the `harness` half below, read by the `session` half — one process, one set.
+    const { homeDir: home, mcpServers, pluginManager, hooks, loadDiskProfiles, logger, maxContextTokens, modelManager, loadConfiguredProviders, infrastructure, sessionCapabilities, extensions, ...engine } = options;
+    // Filled by the `infrastructure` half below, read by the `sessionCapabilities` half — one process, one set.
     let sharedParts = {};
     // Set when the shared skill scan ran through a LocalEnvironment at the default workDir (the host
     // named no environment): that catalog only describes sessions rooted there.
@@ -36,14 +36,15 @@ export async function localHarnessOptions(options) {
         await pluginManager.load();
     // Configured endpoints are resolved once per harness, not per session: the registry is a
     // harness-tier object, and a session only ever reads it.
-    const runtime = modelRuntime ??
+    const runtime = modelManager ??
         ((loadConfiguredProviders ?? true)
-            ? await createModelRuntimeFromConfig({ homeDir })
+            ? await createModelManagerFromConfig({ homeDir })
             : undefined);
     return {
         ...engine,
         ...(extraSubagentProfiles !== undefined ? { extraSubagentProfiles } : {}),
-        harness: async () => {
+        ...(runtime !== undefined ? { modelManager: runtime } : {}),
+        infrastructure: async () => {
             // Disk sessions under <homeDir>/sessions; diagnostics roll on disk under <homeDir>/logs.
             // The MCP connections, the skill scan and the OAuth store are process-wide: one set for
             // every session this harness opens, built once, here.
@@ -56,7 +57,7 @@ export async function localHarnessOptions(options) {
                 // `onStatusChange`, which each session subscribes to when it views it.
                 await servers.connect({ sessionId: "" });
             }
-            const fromHost = await harness?.();
+            const fromHost = await infrastructure?.();
             // Skills follow the EXECUTION environment, not the host's disk: the catalog the model sees
             // must be the one whose scripts its Bash can reach. A host that named an environment above
             // is scanned through it; an environment FACTORY (one per session) has no single filesystem
@@ -85,8 +86,6 @@ export async function localHarnessOptions(options) {
                 ...(servers !== undefined ? { mcpServers: servers } : {}),
                 ...(skillRegistry !== undefined ? { skillRegistry } : {}),
                 ...(pluginManager !== undefined ? { pluginManager } : {}),
-                // What `ExtensionHost.registerProvider` mutates, and where a session's model is looked up.
-                ...(runtime !== undefined ? { modelRuntime: runtime } : {}),
                 ...fromHost,
                 close: async () => {
                     await fromHost?.close?.();
@@ -95,7 +94,7 @@ export async function localHarnessOptions(options) {
             };
             return sharedParts;
         },
-        session: session ??
+        sessionCapabilities: sessionCapabilities ??
             ((ctx) => defaultCapabilities({
                 shared: sessionSharedParts(sharedParts, sharedSkillsWorkDir, ctx.workDir),
                 ownEnvironment: ctx.ownEnvironment,

package/dist/providers.d.ts

@@ -35,11 +35,7 @@
  * ```
  */
 import { z } from "zod";
-import { DecisionModel, type Api, type ChatModel, type Model, type ModelRuntime } from "operon-agents-core";
-import type { Provider } from "@earendil-works/pi-ai";
-/** The wire dialects a configured endpoint can speak. Almost everything speaks the first. */
-export declare const PROVIDER_APIS: readonly ["openai-completions", "openai-responses", "anthropic-messages"];
-export type ProviderApi = (typeof PROVIDER_APIS)[number];
+import { type Api, type ModelManager } from "operon-agents-core";
 declare const ProviderEntrySchema: z.ZodObject<{
     base_url: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
@@ -120,35 +116,8 @@ export declare function parseModelsResponse(body: unknown): readonly string[];
  * Turn one config entry into a provider the engine can stream through. Its model list starts at
  * whatever the config declared and is replaced by the endpoint's on the first refresh.
  */
-export declare function providerFromConfig(providerId: string, entry: ProviderEntry): Provider<Api>;
-/**
- * One model, named by a host that already knows which it wants.
- *
- * The picked fields are pi's own. `baseUrl` is used exactly as given; without it, pi's catalog says
- * where each model lives. The others describe a model the catalog lacks: a catalogued one keeps its own.
- */
-export interface ChatModelConfig extends Readonly<Partial<Pick<Model<Api>, "baseUrl" | "contextWindow" | "maxTokens" | "input" | "reasoning">>> {
-    /** pi's provider id to use its catalog; any other name needs `api` and `baseUrl`. */
-    readonly provider: string;
-    readonly model: string;
-    readonly apiKey?: string;
-    /** Marks a custom endpoint, built with `createProvider`. Only the dialects it can load. */
-    readonly api?: ProviderApi;
-}
-/** Build the `ChatModel` a host picked: from pi's catalog, or from `api` and `baseUrl` for a custom endpoint. */
-export declare function resolveChatModel(config: ChatModelConfig): ChatModel;
-export interface DecisionModelConfig {
-    /** pi's provider id: decision models only exist in its catalog. */
-    readonly provider: string;
-    readonly model: string;
-    readonly apiKey: string;
-}
-/**
- * The decision model a config names, or undefined when it is an LLM. An id catalogued as both
- * (OpenAI's `gpt-6-luna`) counts as an LLM, and an id the catalog doesn't know can only be one.
- */
-export declare function resolveDecisionModel(config: DecisionModelConfig): Promise<DecisionModel | undefined>;
-export interface ModelRuntimeFromConfigOptions {
+export declare function providerFromConfig(providerId: string, entry: ProviderEntry): import("@earendil-works/pi-ai").Provider<Api>;
+export interface ModelManagerFromConfigOptions {
     readonly homeDir: string;
     /**
      * Ask each configured endpoint for its models. Default true. With it off the runtime carries
@@ -163,10 +132,8 @@ export interface ModelRuntimeFromConfigOptions {
  * One model runtime carrying the engine's built-in providers plus everything in
  * `<homeDir>/providers.toml`, with each configured endpoint asked what it serves.
  *
- * Hand the same runtime to `defineModel({ provider, model, runtime })` and to
- * `createLocalHarness({ modelRuntime })`, so the model a host resolves and the models its sessions
- * can switch to come from one registry.
+ * Hand it to `createLocalHarness({ modelManager })`, so every model a session runs on comes from it.
  */
-export declare function createModelRuntimeFromConfig(options: ModelRuntimeFromConfigOptions): Promise<ModelRuntime>;
+export declare function createModelManagerFromConfig(options: ModelManagerFromConfigOptions): Promise<ModelManager>;
 export {};
 //# sourceMappingURL=providers.d.ts.map

package/dist/providers.js

@@ -38,9 +38,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { z } from "zod";
-import { DecisionModel, createModelRuntime, createProvider, defineModel, lazyApi, } from "operon-agents-core";
-/** The wire dialects a configured endpoint can speak. Almost everything speaks the first. */
-export const PROVIDER_APIS = ["openai-completions", "openai-responses", "anthropic-messages"];
+import { NO_KEY_PLACEHOLDER, PROVIDER_APIS, createModelManager, createProvider, dialectStreams, endpointModel, } from "operon-agents-core";
 const ModelOverrideSchema = z.object({
     name: z.string().optional(),
     context_window: z.number().int().positive().optional(),
@@ -99,12 +97,6 @@ export async function loadProviderConfigs(homeDir) {
         };
     }
 }
-/**
- * What a keyless endpoint sends as its bearer token. The engine's OpenAI dialect refuses to build a
- * client without one, and a local server that wants no key ignores whatever arrives; pi uses the
- * same literal for the same reason.
- */
-const NO_KEY_PLACEHOLDER = "unused";
 /** The key this provider authenticates with, or undefined when its env var is declared but unset. */
 function configuredKey(entry) {
     if (entry.api_key !== undefined)
@@ -143,11 +135,9 @@ function configAuth(providerId, entry) {
         },
     };
 }
-/** Zero cost: a self-hosted endpoint has no per-token price, and a wrong number is worse than none. */
-const NO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 function modelFrom(providerId, entry, modelId) {
     const override = entry.models[modelId];
-    return {
+    return endpointModel({
         id: modelId,
         name: override?.name ?? modelId,
         api: (override?.api ?? entry.api),
@@ -155,11 +145,10 @@ function modelFrom(providerId, entry, modelId) {
         baseUrl: entry.base_url,
         reasoning: override?.reasoning ?? entry.reasoning,
         input: (override?.vision ?? entry.vision) ? ["text", "image"] : ["text"],
-        cost: NO_COST,
         contextWindow: override?.context_window ?? entry.context_window,
         maxTokens: override?.max_output_tokens ?? entry.max_output_tokens,
-        ...(entry.headers !== undefined ? { headers: entry.headers } : {}),
-    };
+        headers: entry.headers,
+    });
 }
 /** The model ids an OpenAI-compatible `/models` response lists, in the order the endpoint gave. */
 export function parseModelsResponse(body) {
@@ -215,95 +204,14 @@ export function providerFromConfig(providerId, entry) {
         api: dialectStreams(entry.api),
     });
 }
-/** pi's API implementations load on first use, so an unused dialect is never imported. */
-function dialectStreams(api) {
-    switch (api) {
-        case "anthropic-messages":
-            return lazyApi(() => import("@earendil-works/pi-ai/api/anthropic-messages"));
-        case "openai-responses":
-            return lazyApi(() => import("@earendil-works/pi-ai/api/openai-responses"));
-        case "openai-completions":
-            return lazyApi(() => import("@earendil-works/pi-ai/api/openai-completions"));
-    }
-}
-/** An id newer than a catalog provider's list runs on the API of that provider's default endpoint. */
-function modelNewerThanCatalog(provider, config) {
-    const models = provider.getModels();
-    const template = models.find((model) => model.baseUrl === provider.baseUrl) ?? models[0];
-    if (template === undefined)
-        throw new Error(`Provider "${provider.id}" lists no models to run "${config.model}" like.`);
-    return {
-        id: config.model,
-        name: config.model,
-        api: template.api,
-        provider: provider.id,
-        baseUrl: template.baseUrl,
-        reasoning: config.reasoning ?? false,
-        input: [...(config.input ?? ["text"])],
-        cost: NO_COST,
-        contextWindow: config.contextWindow ?? 128_000,
-        maxTokens: config.maxTokens ?? 8_192,
-    };
-}
-function catalogChatModel(config) {
-    const runtime = createModelRuntime();
-    const provider = runtime.models.getProvider(config.provider);
-    if (provider === undefined) {
-        throw new Error(`Provider "${config.provider}" is not in pi's catalog. Set \`api\` and \`baseUrl\` for a custom endpoint.`);
-    }
-    const descriptor = runtime.models.getModel(config.provider, config.model) ?? modelNewerThanCatalog(provider, config);
-    return defineModel({
-        runtime,
-        descriptor: config.baseUrl === undefined ? descriptor : { ...descriptor, baseUrl: config.baseUrl },
-        ...(config.apiKey !== undefined ? { apiKey: config.apiKey } : {}),
-    });
-}
-function customChatModel(config, api) {
-    if (config.baseUrl === undefined)
-        throw new Error(`Custom provider "${config.provider}" needs a \`baseUrl\`.`);
-    const entry = ProviderEntrySchema.parse({
-        base_url: config.baseUrl,
-        api,
-        api_key: config.apiKey,
-        fetch_models: false,
-        context_window: config.contextWindow,
-        max_output_tokens: config.maxTokens,
-        reasoning: config.reasoning,
-        vision: config.input?.includes("image"),
-        models: { [config.model]: {} },
-    });
-    const runtime = createModelRuntime({ builtins: false });
-    runtime.models.setProvider(providerFromConfig(config.provider, entry));
-    return defineModel({ runtime, descriptor: modelFrom(config.provider, entry, config.model) });
-}
-/** Build the `ChatModel` a host picked: from pi's catalog, or from `api` and `baseUrl` for a custom endpoint. */
-export function resolveChatModel(config) {
-    return config.api === undefined ? catalogChatModel(config) : customChatModel(config, config.api);
-}
-/**
- * The decision model a config names, or undefined when it is an LLM. An id catalogued as both
- * (OpenAI's `gpt-6-luna`) counts as an LLM, and an id the catalog doesn't know can only be one.
- */
-export async function resolveDecisionModel(config) {
-    const runtime = createModelRuntime();
-    if (runtime.models.getModel(config.provider, config.model) !== undefined)
-        return undefined;
-    const descriptor = runtime.models.getModelOfType("classifier", config.provider, config.model);
-    if (descriptor === undefined)
-        return undefined;
-    await runtime.credentials.modify(config.provider, async () => ({ type: "api_key", key: config.apiKey }));
-    return new DecisionModel({ runtime, descriptor });
-}
 /**
  * One model runtime carrying the engine's built-in providers plus everything in
  * `<homeDir>/providers.toml`, with each configured endpoint asked what it serves.
  *
- * Hand the same runtime to `defineModel({ provider, model, runtime })` and to
- * `createLocalHarness({ modelRuntime })`, so the model a host resolves and the models its sessions
- * can switch to come from one registry.
+ * Hand it to `createLocalHarness({ modelManager })`, so every model a session runs on comes from it.
  */
-export async function createModelRuntimeFromConfig(options) {
-    const runtime = createModelRuntime();
+export async function createModelManagerFromConfig(options) {
+    const runtime = createModelManager();
     const { providers, warnings } = await loadProviderConfigs(options.homeDir);
     for (const warning of warnings)
         options.onWarning?.(warning);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "operon-agents",
-  "version": "0.1.0-alpha.29",
+  "version": "0.1.0-alpha.30",
   "description": "Public SDK entrypoint for building agents.",
   "type": "module",
   "engines": {
@@ -70,7 +70,7 @@
     "zod": "^4.4.3",
     "smol-toml": "^1.6.1",
     "@earendil-works/pi-ai": "1.5.0",
-    "operon-agents-core": "0.1.0-alpha.29"
+    "operon-agents-core": "0.1.0-alpha.30"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "1.5.0"