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

package/README.md

@@ -3,7 +3,8 @@
 Public SDK entrypoint for building agents.
 
 ```ts
-import { Agent, Runner, Session, ChatModel, tool } from "operon-agents";
+import { Agent, ChatModel, defineTool } from "operon-agents";
+import { Runner, Session } from "operon-agents/advanced";
 ```
 
 Use `operon-agents` from applications. `operon-agents-core` is the lower-level
@@ -43,7 +44,7 @@ const provider = new NodeTracerProvider({
 const tracing = new OTelTracingProcessor({ tracer: provider.getTracer("my-agent"), tracerProvider: provider, content: "delta", shutdownProvider: true });
 
 const harness = await createLocalHarness({
-  model,
+  config: { defaults: { model } },
   infrastructure: () => ({ tracing }),
 });
 ```

package/dist/advanced.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `operon-agents/advanced` — everything beyond the main entry point: extension and cron plumbing,
+ * custom capabilities, stores, providers, MCP wiring and the event and store contracts.
+ *
+ * Supported, but for hosts composing their own deployment. Most applications only need
+ * `operon-agents`. Engine internals with no stability guarantee live on `operon-agents/internal`.
+ */
+export * from "./harness.ts";
+export * from "./extensions/index.ts";
+export * from "./cron/index.ts";
+export * from "./providers.ts";
+export * from "./local.ts";
+export * from "./workspace-mcp.ts";
+export * from "operon-agents-core";
+//# sourceMappingURL=advanced.d.ts.map

package/dist/advanced.js

@@ -0,0 +1,15 @@
+/**
+ * `operon-agents/advanced` — everything beyond the main entry point: extension and cron plumbing,
+ * custom capabilities, stores, providers, MCP wiring and the event and store contracts.
+ *
+ * Supported, but for hosts composing their own deployment. Most applications only need
+ * `operon-agents`. Engine internals with no stability guarantee live on `operon-agents/internal`.
+ */
+export * from "./harness.js";
+export * from "./extensions/index.js";
+export * from "./cron/index.js";
+export * from "./providers.js";
+export * from "./local.js";
+export * from "./workspace-mcp.js";
+export * from "operon-agents-core";
+//# sourceMappingURL=advanced.js.map

package/dist/app-server/client.d.ts

@@ -7,7 +7,7 @@
  * in-process for tests.
  */
 import { type ChildProcess } from "node:child_process";
-import type { AgentEvent, ApprovalRequest, ApprovalResponse, QuestionRequest, QuestionResult, RunResult, SessionSummary } from "operon-agents-core";
+import type { AgentEvent, ApprovalRequest, ApprovalResponse, QuestionRequest, QuestionResult, RunResult, SessionConfig, SessionSummary } from "operon-agents-core";
 import { type JsonRpcTransport } from "./codec.ts";
 import { type ClientCapabilities, type InitializeResult, type SessionFollowUpResult, type SessionInfo, type SessionSnapshotResult, type SessionSteerResult } from "./protocol.ts";
 export type ApprovalHandler = (request: ApprovalRequest, sessionId: string) => Promise<ApprovalResponse> | ApprovalResponse;
@@ -49,10 +49,12 @@ export declare class AppServerClient {
         workDir?: string;
         title?: string;
         model?: string;
+        config?: SessionConfig;
     }): Promise<SessionInfo>;
     resumeSession(sessionId: string): Promise<SessionInfo>;
     forkSession(sessionId: string, opts?: {
         title?: string;
+        config?: SessionConfig;
     }): Promise<SessionInfo>;
     listSessions(): Promise<readonly SessionSummary[]>;
     closeSession(sessionId: string): Promise<unknown>;

package/dist/app-server/main.js

@@ -5,14 +5,22 @@
  *
  *   operon-app-server --home ~/.agent --workdir /repo --model anthropic/claude-opus-4-...
  *
+ * Configuration comes from the same `config.toml` files any other host reads (`loadHarnessConfig`:
+ * `<home>/config.toml`, then the working directory's `.agents/config.toml` and
+ * `.agents/config.local.toml`), with the command-line flags laid over it. `--no-config` skips the
+ * files.
+ *
  * stdout carries the protocol (NDJSON JSON-RPC). stderr is logs. We defensively
  * redirect console.log/info/debug to stderr so a stray log can never corrupt the
  * protocol stream.
  */
-import { DiskSessionRepository } from "operon-agents-core";
+import { DiskSessionRepository, loadHarnessConfig } from "operon-agents-core";
 import { createHarness } from "../harness.js";
 import { nodeStreamTransport } from "./codec.js";
 import { AppServer } from "./server.js";
+const PERMISSION_MODES = ["manual", "workspace", "yolo", "auto"];
+/** What this binary has always run on when nothing names a model. */
+const FALLBACK_MODEL = "anthropic/claude-opus-4-8";
 function parseArgs(argv) {
     const out = {};
     for (let i = 0; i < argv.length; i++) {
@@ -31,10 +39,13 @@ function parseArgs(argv) {
                 break;
             case "--permission": {
                 const mode = take();
-                if (mode === "manual" || mode === "workspace" || mode === "yolo")
+                if (PERMISSION_MODES.includes(mode))
                     out.permission = mode;
                 break;
             }
+            case "--no-config":
+                out.noConfig = true;
+                break;
             default:
                 break;
         }
@@ -52,11 +63,25 @@ function redirectStdoutLogsToStderr() {
 async function main() {
     redirectStdoutLogsToStderr();
     const args = parseArgs(process.argv.slice(2));
+    // The files first, the flags over them: one configuration, whichever way it was written.
+    const file = args.noConfig === true
+        ? { defaults: {} }
+        : await loadHarnessConfig({
+            ...(args.home !== undefined ? { homeDir: args.home } : {}),
+            ...(args.workdir !== undefined ? { cwd: args.workdir } : {}),
+        });
+    const config = {
+        ...file,
+        defaults: {
+            ...file.defaults,
+            model: args.model ?? file.defaults.model ?? FALLBACK_MODEL,
+            ...(args.permission !== undefined ? { permission: { ...file.defaults.permission, mode: args.permission } } : {}),
+        },
+        ...(args.workdir !== undefined ? { workDir: args.workdir } : {}),
+    };
     const harness = createHarness({
-        model: args.model ?? "anthropic/claude-opus-4-8",
+        config,
         ...(args.home !== undefined ? { infrastructure: () => ({ sessionRepository: new DiskSessionRepository(args.home) }) } : {}),
-        ...(args.workdir !== undefined ? { workDir: args.workdir } : {}),
-        permission: { mode: args.permission ?? "yolo" },
     });
     const transport = nodeStreamTransport(process.stdin, process.stdout, {
         onParseError: (line, error) => process.stderr.write(`parse error: ${String(error)} on: ${line.slice(0, 200)}\n`),

package/dist/app-server/params.d.ts

@@ -5,7 +5,7 @@
  * handler touches it. A miss is an `InvalidParams` error that names the field.
  */
 import { z } from "zod";
-import type { Message, QuestionItem } from "operon-agents-core";
+import { type Message, type QuestionItem, type SessionConfig } from "operon-agents-core";
 import type { ClientCancelRequestParams, ClientRequestApprovalParams, ClientRequestQuestionParams, InitializeParams, SessionFollowUpParams, SessionForkParams, SessionInvokeParams, SessionNewParams, SessionPromptParams, SessionRef, SessionRespondParams, SessionResumeParams, SessionSnapshotParams, SessionSteerParams } from "./protocol.ts";
 export declare const SessionRefSchema: z.ZodObject<{
     sessionId: z.ZodString;
@@ -25,12 +25,426 @@ export declare const SessionNewParamsSchema: z.ZodObject<{
     workDir: z.ZodOptional<z.ZodString>;
     title: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        modelSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        thinking: z.ZodOptional<z.ZodString>;
+        agent: z.ZodOptional<z.ZodString>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        appendSystemPrompt: z.ZodOptional<z.ZodString>;
+        mcp: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            servers: z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    http: "http";
+                }>>;
+                transport: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    http: "http";
+                }>>;
+                command: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                cwd: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                blockedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                bearerTokenEnvVar: z.ZodOptional<z.ZodString>;
+                keepAliveIntervalMs: z.ZodOptional<z.ZodNumber>;
+                keepAliveTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                oauth: z.ZodOptional<z.ZodObject<{
+                    clientId: z.ZodString;
+                    clientSecret: z.ZodOptional<z.ZodString>;
+                    callbackPort: z.ZodOptional<z.ZodNumber>;
+                    callbackUrl: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>, z.ZodTransform<{
+                transport: "stdio" | "http";
+                command?: string | undefined;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                url?: string | undefined;
+                env?: Record<string, string> | undefined;
+                headers?: Record<string, string> | undefined;
+                allowedTools?: string[] | undefined;
+                blockedTools?: string[] | undefined;
+                enabled?: boolean | undefined;
+                startupTimeoutMs?: number | undefined;
+                toolTimeoutMs?: number | undefined;
+                bearerTokenEnvVar?: string | undefined;
+                keepAliveIntervalMs?: number | undefined;
+                keepAliveTimeoutMs?: number | undefined;
+                oauth?: {
+                    clientId: string;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+            }, {
+                type?: "stdio" | "http" | undefined;
+                transport?: "stdio" | "http" | undefined;
+                command?: string | undefined;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                url?: string | undefined;
+                env?: Record<string, string> | undefined;
+                headers?: Record<string, string> | undefined;
+                allowedTools?: string[] | undefined;
+                blockedTools?: string[] | undefined;
+                enabled?: boolean | undefined;
+                startupTimeoutMs?: number | undefined;
+                toolTimeoutMs?: number | undefined;
+                bearerTokenEnvVar?: string | undefined;
+                keepAliveIntervalMs?: number | undefined;
+                keepAliveTimeoutMs?: number | undefined;
+                oauth?: {
+                    clientId: string;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+            }>>>>;
+        }, z.core.$strict>]>>;
+        skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            roots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            includeDefaultRoots: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>]>>;
+        hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            matcher: z.ZodOptional<z.ZodString>;
+            command: z.ZodString;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        permission: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                manual: "manual";
+                workspace: "workspace";
+                yolo: "yolo";
+            }>>;
+            autoApproval: z.ZodOptional<z.ZodObject<{
+                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                environment: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                twoStageMode: z.ZodOptional<z.ZodEnum<{
+                    thinking: "thinking";
+                    both: "both";
+                    fast: "fast";
+                }>>;
+            }, z.core.$strict>>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                decision: z.ZodEnum<{
+                    allow: "allow";
+                    deny: "deny";
+                    ask: "ask";
+                }>;
+                scope: z.ZodEnum<{
+                    user: "user";
+                    "turn-override": "turn-override";
+                    "session-runtime": "session-runtime";
+                    project: "project";
+                }>;
+                pattern: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strict>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        subagents: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            workflowTool: z.ZodOptional<z.ZodBoolean>;
+            maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        limits: z.ZodOptional<z.ZodObject<{
+            maxTurns: z.ZodOptional<z.ZodNumber>;
+            maxStepsPerTurn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodTransform<SessionConfig, {
+        model?: string | undefined;
+        modelSettings?: Record<string, unknown> | undefined;
+        thinking?: string | undefined;
+        agent?: string | undefined;
+        tools?: string[] | undefined;
+        appendSystemPrompt?: string | undefined;
+        mcp?: false | {
+            servers: Record<string, {
+                transport: "stdio" | "http";
+                command?: string | undefined;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                url?: string | undefined;
+                env?: Record<string, string> | undefined;
+                headers?: Record<string, string> | undefined;
+                allowedTools?: string[] | undefined;
+                blockedTools?: string[] | undefined;
+                enabled?: boolean | undefined;
+                startupTimeoutMs?: number | undefined;
+                toolTimeoutMs?: number | undefined;
+                bearerTokenEnvVar?: string | undefined;
+                keepAliveIntervalMs?: number | undefined;
+                keepAliveTimeoutMs?: number | undefined;
+                oauth?: {
+                    clientId: string;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+            }>;
+        } | undefined;
+        skills?: false | {
+            roots?: string[] | undefined;
+            includeDefaultRoots?: boolean | undefined;
+        } | undefined;
+        hooks?: {
+            event: string;
+            command: string;
+            matcher?: string | undefined;
+            timeout?: number | undefined;
+        }[] | undefined;
+        permission?: {
+            mode?: "manual" | "auto" | "workspace" | "yolo" | undefined;
+            autoApproval?: {
+                allow?: string[] | undefined;
+                deny?: string[] | undefined;
+                environment?: string[] | undefined;
+                twoStageMode?: "thinking" | "both" | "fast" | undefined;
+            } | undefined;
+            rules?: {
+                decision: "allow" | "deny" | "ask";
+                scope: "user" | "turn-override" | "session-runtime" | "project";
+                pattern: string;
+                reason?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        extensions?: Record<string, unknown> | undefined;
+        subagents?: false | {
+            workflowTool?: boolean | undefined;
+            maxConcurrent?: number | undefined;
+        } | undefined;
+        limits?: {
+            maxTurns?: number | undefined;
+            maxStepsPerTurn?: number | undefined;
+        } | undefined;
+    }>>>;
 }, z.core.$strip>;
 export declare const SessionResumeParamsSchema: z.ZodObject<{
     sessionId: z.ZodString;
 }, z.core.$strip>;
 export declare const SessionForkParamsSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodPipe<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        modelSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        thinking: z.ZodOptional<z.ZodString>;
+        agent: z.ZodOptional<z.ZodString>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        appendSystemPrompt: z.ZodOptional<z.ZodString>;
+        mcp: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            servers: z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodPipe<z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    http: "http";
+                }>>;
+                transport: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    http: "http";
+                }>>;
+                command: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                cwd: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                blockedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                startupTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                toolTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                bearerTokenEnvVar: z.ZodOptional<z.ZodString>;
+                keepAliveIntervalMs: z.ZodOptional<z.ZodNumber>;
+                keepAliveTimeoutMs: z.ZodOptional<z.ZodNumber>;
+                oauth: z.ZodOptional<z.ZodObject<{
+                    clientId: z.ZodString;
+                    clientSecret: z.ZodOptional<z.ZodString>;
+                    callbackPort: z.ZodOptional<z.ZodNumber>;
+                    callbackUrl: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>, z.ZodTransform<{
+                transport: "stdio" | "http";
+                command?: string | undefined;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                url?: string | undefined;
+                env?: Record<string, string> | undefined;
+                headers?: Record<string, string> | undefined;
+                allowedTools?: string[] | undefined;
+                blockedTools?: string[] | undefined;
+                enabled?: boolean | undefined;
+                startupTimeoutMs?: number | undefined;
+                toolTimeoutMs?: number | undefined;
+                bearerTokenEnvVar?: string | undefined;
+                keepAliveIntervalMs?: number | undefined;
+                keepAliveTimeoutMs?: number | undefined;
+                oauth?: {
+                    clientId: string;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+            }, {
+                type?: "stdio" | "http" | undefined;
+                transport?: "stdio" | "http" | undefined;
+                command?: string | undefined;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                url?: string | undefined;
+                env?: Record<string, string> | undefined;
+                headers?: Record<string, string> | undefined;
+                allowedTools?: string[] | undefined;
+                blockedTools?: string[] | undefined;
+                enabled?: boolean | undefined;
+                startupTimeoutMs?: number | undefined;
+                toolTimeoutMs?: number | undefined;
+                bearerTokenEnvVar?: string | undefined;
+                keepAliveIntervalMs?: number | undefined;
+                keepAliveTimeoutMs?: number | undefined;
+                oauth?: {
+                    clientId: string;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+            }>>>>;
+        }, z.core.$strict>]>>;
+        skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            roots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            includeDefaultRoots: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>]>>;
+        hooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodString;
+            matcher: z.ZodOptional<z.ZodString>;
+            command: z.ZodString;
+            timeout: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        permission: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                auto: "auto";
+                manual: "manual";
+                workspace: "workspace";
+                yolo: "yolo";
+            }>>;
+            autoApproval: z.ZodOptional<z.ZodObject<{
+                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                environment: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                twoStageMode: z.ZodOptional<z.ZodEnum<{
+                    thinking: "thinking";
+                    both: "both";
+                    fast: "fast";
+                }>>;
+            }, z.core.$strict>>;
+            rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                decision: z.ZodEnum<{
+                    allow: "allow";
+                    deny: "deny";
+                    ask: "ask";
+                }>;
+                scope: z.ZodEnum<{
+                    user: "user";
+                    "turn-override": "turn-override";
+                    "session-runtime": "session-runtime";
+                    project: "project";
+                }>;
+                pattern: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strict>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        subagents: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+            workflowTool: z.ZodOptional<z.ZodBoolean>;
+            maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        limits: z.ZodOptional<z.ZodObject<{
+            maxTurns: z.ZodOptional<z.ZodNumber>;
+            maxStepsPerTurn: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodTransform<SessionConfig, {
+        model?: string | undefined;
+        modelSettings?: Record<string, unknown> | undefined;
+        thinking?: string | undefined;
+        agent?: string | undefined;
+        tools?: string[] | undefined;
+        appendSystemPrompt?: string | undefined;
+        mcp?: false | {
+            servers: Record<string, {
+                transport: "stdio" | "http";
+                command?: string | undefined;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                url?: string | undefined;
+                env?: Record<string, string> | undefined;
+                headers?: Record<string, string> | undefined;
+                allowedTools?: string[] | undefined;
+                blockedTools?: string[] | undefined;
+                enabled?: boolean | undefined;
+                startupTimeoutMs?: number | undefined;
+                toolTimeoutMs?: number | undefined;
+                bearerTokenEnvVar?: string | undefined;
+                keepAliveIntervalMs?: number | undefined;
+                keepAliveTimeoutMs?: number | undefined;
+                oauth?: {
+                    clientId: string;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                } | undefined;
+                scopes?: string[] | undefined;
+            }>;
+        } | undefined;
+        skills?: false | {
+            roots?: string[] | undefined;
+            includeDefaultRoots?: boolean | undefined;
+        } | undefined;
+        hooks?: {
+            event: string;
+            command: string;
+            matcher?: string | undefined;
+            timeout?: number | undefined;
+        }[] | undefined;
+        permission?: {
+            mode?: "manual" | "auto" | "workspace" | "yolo" | undefined;
+            autoApproval?: {
+                allow?: string[] | undefined;
+                deny?: string[] | undefined;
+                environment?: string[] | undefined;
+                twoStageMode?: "thinking" | "both" | "fast" | undefined;
+            } | undefined;
+            rules?: {
+                decision: "allow" | "deny" | "ask";
+                scope: "user" | "turn-override" | "session-runtime" | "project";
+                pattern: string;
+                reason?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        extensions?: Record<string, unknown> | undefined;
+        subagents?: false | {
+            workflowTool?: boolean | undefined;
+            maxConcurrent?: number | undefined;
+        } | undefined;
+        limits?: {
+            maxTurns?: number | undefined;
+            maxStepsPerTurn?: number | undefined;
+        } | undefined;
+    }>>>;
     sessionId: z.ZodString;
 }, z.core.$strip>;
 export declare const SessionCloseParamsSchema: z.ZodObject<{

package/dist/app-server/params.js

@@ -5,6 +5,7 @@
  * handler touches it. A miss is an `InvalidParams` error that names the field.
  */
 import { z } from "zod";
+import { SessionConfigSchema } from "operon-agents-core";
 import { ErrorCode, INVOKABLE_METHODS } from "./protocol.js";
 import { RpcError } from "./codec.js";
 const sessionRef = { sessionId: z.string().min(1, "sessionId required") };
@@ -14,13 +15,16 @@ export const InitializeParamsSchema = z.object({
     clientInfo: z.object({ name: z.string(), version: z.string().optional() }).optional(),
     clientCapabilities: z.object({ approval: z.boolean().optional(), question: z.boolean().optional() }).optional(),
 });
+/** The one session-configuration schema, as every other entry point validates it. */
+const sessionConfig = SessionConfigSchema.transform((value) => value).optional();
 export const SessionNewParamsSchema = z.object({
     workDir: z.string().optional(),
     title: z.string().optional(),
     model: z.string().optional(),
+    config: sessionConfig,
 });
 export const SessionResumeParamsSchema = SessionRefSchema;
-export const SessionForkParamsSchema = z.object({ ...sessionRef, title: z.string().optional() });
+export const SessionForkParamsSchema = z.object({ ...sessionRef, title: z.string().optional(), config: sessionConfig });
 export const SessionCloseParamsSchema = SessionRefSchema;
 export const SessionCancelParamsSchema = SessionRefSchema;
 const isMessageLike = (value) => typeof value === "object" && value !== null && typeof value.role === "string";

package/dist/app-server/protocol.d.ts

@@ -16,7 +16,7 @@
  *   server → host  request       reverse-RPC: `client/requestApproval` / `…Question`
  *   host → server  response      the host's answer to a reverse-RPC request
  */
-import type { AgentEvent, AgentInput, ApprovalRequest, ApprovalResponse, PermissionMode, QuestionRequest, QuestionResult, RunResult, SessionSnapshot, SessionSummary } from "operon-agents-core";
+import type { AgentEvent, AgentInput, ApprovalRequest, ApprovalResponse, PermissionMode, QuestionRequest, QuestionResult, RunResult, SessionConfig, SessionSnapshot, SessionSummary } from "operon-agents-core";
 /** Bump on any breaking wire change. Integer, not semver. */
 export declare const PROTOCOL_VERSION = 1;
 export type JsonRpcId = string | number;
@@ -114,8 +114,16 @@ export interface InitializeResult {
 export interface SessionNewParams {
     readonly workDir?: string;
     readonly title?: string;
-    /** Per-session model id (`provider/model`), applied via setModel after creation. */
+    /** Per-session model id (`provider/model`). Shorthand for `config.model`, which it overrides. */
     readonly model?: string;
+    /**
+     * The session's setup, as data: model, tool and agent NAMES registered on the server's harness,
+     * MCP servers, permission, extension parameters, limits. A field given replaces the server's
+     * default; a field left out inherits it. Stored with the session, so `session/resume` needs none
+     * of it repeated. It is checked against the server's policy like any other configuration — the
+     * wire is not a way around it.
+     */
+    readonly config?: SessionConfig;
 }
 export interface SessionRef {
     readonly sessionId: string;
@@ -128,6 +136,8 @@ export interface SessionResumeParams extends SessionRef {
 }
 export interface SessionForkParams extends SessionRef {
     readonly title?: string;
+    /** Adjustments to the source session's setup, field by field. See `SessionNewParams.config`. */
+    readonly config?: SessionConfig;
 }
 export interface SessionCloseParams extends SessionRef {
 }
@@ -178,9 +188,8 @@ export interface SessionFollowUpParams extends SessionRef {
     readonly text: string;
 }
 export interface SessionFollowUpResult {
-    /** False when the session has no active run; callers should use `session/prompt` instead. */
     readonly accepted: boolean;
-    /** Correlation id (see `SessionSteerResult.steerId`); absent when not accepted. */
+    /** Correlation id (see `SessionSteerResult.steerId`). */
     readonly steerId?: string;
 }
 export interface SessionCancelParams extends SessionRef {