fix(core): use long mcp tool timeout

.opencode/plugins/orchestrator.ts

@@ -0,0 +1,36 @@
+export default {
+  id: "Orchestrator",
+  setup: async (ctx) => {
+    await ctx.agent.transform((agents) => {
+      agents.update("orchestrator", (agent) => {
+        agent.description = "Coordinates work by delegating implementation tasks to the minion subagent."
+        agent.mode = "primary"
+        agent.system = [
+          "You are Orchestrator, the primary coordinating agent for this repository. You do meta work only: you coordinate, brief, and synthesize — you do not perform the work itself.",
+          "Delegate ALL actual work to the minion subagent — implementation, exploration, discovery, searching the codebase, reading files to understand a problem, and even trivial one-line edits. Task size is never a reason to do it yourself, and there is no 'final integration' exception.",
+          "You are not hard-banned from tools, but direct tool use is reserved for coordination overhead: a quick peek to phrase a better brief, a fast read-only check to verify a minion's reported result, or answering a question about coordination state. If a tool call is producing the answer or the artifact the user asked for, that call belongs to a minion, not you.",
+          "Exploration is work. If the user asks how something works or where something lives, delegate the investigation to a minion rather than exploring yourself.",
+          "Always start minion subagents in the background. Even if you have nothing else to coordinate right now, the user may assign you new work while a Minion runs, and you must stay free to receive it. Never poll; you will be notified when they finish.",
+          "Give each minion a clear, self-contained brief: the goal, constraints, expected output, and any files or context already known from the user or previous minion reports.",
+          "Synthesize minion results, decide next steps, and report back concisely.",
+        ].join("\n")
+      })
+
+      agents.update("minion", (agent) => {
+        agent.description = "Subagent that executes focused tasks delegated by Orchestrator."
+        agent.mode = "subagent"
+        agent.model = { providerID: "opencode", id: "glm-5.2" }
+        agent.system = [
+          "You are minion, a focused execution subagent for this repository.",
+          "Complete the specific task delegated to you by Orchestrator using the available tools.",
+          "Inspect the codebase before making assumptions, make targeted changes when requested, and verify your work when feasible.",
+          "Follow the repository's AGENTS.md conventions: respect the style guide, run `bun typecheck` from the affected package directory after code changes, never run tests from the repo root, and do not modify packages/opencode unless the task explicitly says V1 work.",
+          "If the task is ambiguous or you hit a blocker, stop and report your findings instead of guessing.",
+          "Keep your final response concise: summarize what you did, list important files changed or findings, and call out blockers or verification gaps.",
+          "Do not delegate to other subagents; execute the assigned work yourself.",
+        ].join("\n")
+        agent.permissions.push({ action: "subagent", resource: "*", effect: "deny" })
+      })
+    })
+  },
+}

.opencode/skills/debug-opencode/SKILL.md

@@ -104,25 +104,6 @@ bun dev api <operationId> --param key=value
 - If no compatible background server is registered, `bun dev api` starts one through the daemon service. Use `bun dev service status`, `bun dev service restart`, and `bun dev service stop` when you need explicit lifecycle control.
 - Prefer raw method/path calls for quick server debugging and operation IDs when exercising documented OpenAPI routes with path or query parameters.
 
-## Auditing installed `opencode2` sessions
-
-Installed next-channel sessions normally use `~/.local/share/opencode/opencode-next.db` and `~/.local/share/opencode/log/opencode.log`; `OPENCODE_DB` can override the database. Before calling `opencode2 api`, inspect `~/.local/state/opencode/service.json` because the command may start a daemon when none is healthy.
-
-For a supplied `ses_...` ID, compare three sources:
-
-- `opencode2 api get /api/session/active` and the Session/message endpoints for live server state.
-- The database's ordered `event` rows for durable history.
-- `packages/tui/src/context/data.tsx` and the relevant route for client projection and rendering.
-
-Locate an uncertain database without modifying it:
-
-```bash
-SESSION=ses_...
-for db in ~/.local/share/opencode/*.db; do
-  sqlite3 "file:$db?mode=ro" "select 1 from session where id='$SESSION' limit 1" 2>/dev/null | grep -q 1 && printf '%s\n' "$db"
-done
-```
-
 ## Logs
 
 - Log files live under `~/.local/share/opencode/log/`. In a local/dev checkout the active file is `opencode-local.log`; `opencode.log` is used for non-local (released) channel installs. Both are append-only, shared across every CLI and server process on the machine.

AGENTS.md

@@ -151,15 +151,13 @@ const table = sqliteTable("session", {
 
 ## V2 Session Core
 
-- Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
 - Keep durable prompt admission separate from model execution. `SessionV2.prompt(...)` admits one durable `session_input` row before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. The serialized runner promotes admitted inputs into visible user messages at safe boundaries.
 - Reusing a Session ID adopts the existing Session. Reusing a prompt message ID reconciles an exact retry only when Session, prompt, and delivery mode match; conflicting reuse fails. Historical projected prompts lazily synthesize promoted inbox records during exact retry.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; idle or missing interruption is a no-op.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
-- Preserve one explicit `llm.stream(request)` call per step and reload projected history before durable continuation. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
+- Preserve one explicit `llm.stream(request)` call per provider turn and reload projected history before durable continuation. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash continuation recovery requires a separate explicit design before it may retry provider work. A drain has no durable identity or transcript boundary.
-- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe step boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's step allowance; a batch of steers resets it once.
-- One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
+- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe provider-turn boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's provider-turn allowance; a batch of steers resets it once.
 - Keep EventV2 replay owner claims separate from clustered Session execution ownership.
 - Keep the System Context algebra and built-ins in `src/system-context`; keep Context Source producers with their observed domains, and keep Session History selection plus Context Checkpoint persistence Session-owned. The runner composes all context producers explicitly in `loadSystemContext`; there is no context registry.
 - The durable Applied record is what the model was last told, per source. Reconcile narrates drift as chronological System updates and never rewrites the baseline; only completed compaction rebaselines, and move or committed revert resets the checkpoint. Unavailable sources keep the model's prior belief, blocking only a session's first baseline.

CONTEXT.md

@@ -9,7 +9,7 @@ The structured collection of contextual facts presented to the model as initial
 _Avoid_: System prompt
 
 **Session History**:
-The projected chronological conversation selected for a **Step** after applying the active compaction and **Context Epoch** cutoffs.
+The projected chronological conversation selected for a provider turn after applying the active compaction and **Context Epoch** cutoffs.
 _Avoid_: Session Context
 
 **Context Source**:
@@ -31,13 +31,13 @@ The full **System Context** rendered at the start of a **Context Epoch**.
 _Avoid_: Live system prompt
 
 **Context Snapshot**:
-The overwriteable model-hidden JSON state used to compare each **Context Source** with the value last admitted to a **Step**.
+The overwriteable model-hidden JSON state used to compare each **Context Source** with the value last admitted to a provider turn.
 
 **Unavailable Context**:
 An expected temporary inability to observe a **Context Source** value; the runtime retains its prior effective state and emits no update, or omits it until first successfully loaded.
 
-**Safe Step Boundary**:
-The point immediately before a provider request, after durable input promotion and any required tool settlement, where context changes may be admitted chronologically.
+**Safe Provider-Turn Boundary**:
+The point immediately before a provider call, after durable input promotion and any required tool settlement, where context changes may be admitted chronologically.
 
 **Admitted Prompt**:
 A durable user input accepted into the Session inbox but not yet included in **Session History**.
@@ -45,24 +45,11 @@ A durable user input accepted into the Session inbox but not yet included in **S
 **Prompt Promotion**:
 The durable transition that removes an **Admitted Prompt** from pending input and appends its user message to **Session History**.
 
-**Step**:
-One logical LLM call spanning pre-flight context checkpoint preparation, input promotion, request build, and compaction check; the provider stream; and tool settlement.
-_Avoid_: provider turn, turn (unqualified)
-
-**Physical Attempt**:
-One actual provider request on the wire in service of a **Step**; most Steps have one Physical Attempt, while overflow-triggered compaction recovery may give one Step two.
-
-**Assistant Turn**:
-A reserved name for the not-yet-modeled unit containing all **Steps** from prompt promotion until the assistant yields the floor; do not reify it until something durable needs it.
-
-**Settlement**:
-The terminal transition for a unit of work: Step and tool settlement are durable, while drain and execution settlement are coordinator-observed.
-
-**Execution**:
-One session-scoped coordinator busy period from first wake until idle. An Execution is process-local coordination rather than a durable domain entity.
+**Provider Turn**:
+One request to a model provider and the response projected from that request.
 
 **Session Drain**:
-One process-local execution span that promotes eligible input and runs required **Steps** until no immediate continuation remains. A Session Drain has no durable identity or transcript boundary.
+One process-local execution span that promotes eligible input and runs required **Provider Turns** until no immediate continuation remains. A Session Drain has no durable identity or transcript boundary.
 
 **Model Tool Output**:
 The bounded projection of a Core-executed tool result persisted in Session history and replayed to the model. A tool may shape this projection semantically, but the Tool Registry enforces the final size limit.
@@ -102,25 +89,23 @@ _Avoid_: Response envelope
 
 - A **System Context** is an opaque carrier composed from zero or more **Context Sources**.
 - **Session History** contains projected conversational messages and admitted **Mid-Conversation System Messages**; the active **Baseline System Context** remains separate provider-request state.
-- The **System Context Registry** uses stable-keyed scoped contributions to assemble the current **System Context**; contributor removal naturally removes its sources at the next **Safe Step Boundary**.
+- The **System Context Registry** uses stable-keyed scoped contributions to assemble the current **System Context**; contributor removal naturally removes its sources at the next **Safe Provider-Turn Boundary**.
 - A changed **Context Source** may produce one **Mid-Conversation System Message** containing its newly effective state.
 - A **Mid-Conversation System Message** persists the exact combined rendered text sent to the model.
 - The current **Context Snapshot** advances atomically with the corresponding durable **Mid-Conversation System Message**.
 - A **Context Snapshot** stores one codec-encoded JSON value and, for removable dynamic sources, a pre-rendered removal message per stable **Context Source** key.
 - Changes from multiple **Context Sources** admitted at one safe boundary combine into one **Mid-Conversation System Message**.
-- Context changes are sampled and admitted lazily at a **Safe Step Boundary**, never pushed asynchronously when their source changes.
-- At a **Safe Step Boundary**, newly promoted user input or settled tool results precede any combined **Mid-Conversation System Message**.
+- Context changes are sampled and admitted lazily at a **Safe Provider-Turn Boundary**, never pushed asynchronously when their source changes.
+- At a **Safe Provider-Turn Boundary**, newly promoted user input or settled tool results precede any combined **Mid-Conversation System Message**.
 - An **Admitted Prompt** is replayable pending input, not yet model-visible **Session History**.
 - **Prompt Promotion** atomically consumes the pending inbox entry and appends its model-visible user message.
-- Steering prompts promote at the next **Safe Step Boundary** while the current **Session Drain** still requires continuation. Promoting any newly admitted user input resets the selected agent's step allowance; multiple prompts promoted at one boundary reset it once.
+- Steering prompts promote at the next **Safe Provider-Turn Boundary** while the current **Session Drain** still requires continuation. Promoting any newly admitted user input resets the selected agent's provider-turn allowance; multiple prompts promoted at one boundary reset it once.
 - A queued prompt does not promote while the current **Session Drain** requires continuation. The runner promotes one queued prompt when the Session would otherwise become idle, then reevaluates continuation before promoting another.
-- A **Session Drain** is process-local coordination rather than a durable domain entity. Durable recovery must reason from prompts, projected history, physical attempts, and tool state rather than inventing an enclosing execution identity.
-- An **Execution** contains one or more **Session Drains**; a **Session Drain** contains one reserved assistant-turn span at a time; that span contains **Steps**; and each **Step** contains one or more **Physical Attempts** plus any tool calls it requires.
-- A **Step** record covers only the model-visible span from first assistant output through tool settlement; pre-flight leaves no record, and one Step settles at most one record.
-- The first **Step** renders the latest complete **Baseline System Context** and initializes its **Context Snapshot** without emitting a redundant **Mid-Conversation System Message**; unavailable initial context blocks the Step instead of persisting an incomplete baseline.
+- A **Session Drain** is process-local coordination rather than a durable domain entity. Durable recovery must reason from prompts, projected history, provider attempts, and tool state rather than inventing an enclosing execution identity.
+- The first provider turn renders the latest complete **Baseline System Context** and initializes its **Context Snapshot** without emitting a redundant **Mid-Conversation System Message**; unavailable initial context blocks the turn instead of persisting an incomplete baseline.
 - Initial **System Context** preparation precedes the first durable input promotion so an unavailable baseline leaves that input pending and retryable; ordinary reconciliation remains after promotion.
 - Compaction starts a new **Context Epoch** with a freshly rendered **Baseline System Context** and **Context Snapshot**; prior **Mid-Conversation System Messages** remain durable audit history but leave projected model history.
-- A newly registered core or plugin-defined **Context Source** absent from the current snapshot emits its baseline rendering once at the next **Safe Step Boundary**.
+- A newly registered core or plugin-defined **Context Source** absent from the current snapshot emits its baseline rendering once at the next **Safe Provider-Turn Boundary**.
 - **Context Source** keys are stable and namespaced; duplicate keys fail composition. `SystemContext.combine(...)` preserves caller order; the **System Context Registry** evaluates producers concurrently and combines them in stable contribution-key order so rendered context remains deterministic.
 - Each **Context Source** loader returns one coherent typed value. `SystemContext.make(...)` hides that value type so differently typed sources compose uniformly. Its codec compares and stores that value; its pure renderers produce model-visible baseline, update, and removal text only when needed.
 - `SystemContext.initialize(...)` observes a composed **System Context** once and produces a fresh **Baseline System Context** with its **Context Snapshot**.
@@ -128,26 +113,26 @@ _Avoid_: Response envelope
 - `SystemContext.replace(...)` renders a fresh generation after completed compaction or another baseline-replacing transition; it reports replacement blocked while previously admitted context is unavailable.
 - **Unavailable Context** uses stale-while-revalidate semantics and is distinct from a successfully loaded absence, which may emit removal text.
 - Ordinary **Context Source** loaders return values directly; loaders that intentionally use stale-while-revalidate may explicitly return **Unavailable Context**.
-- Nested project instruction discovery after successful reads remains a follow-up; when implemented, discovered instructions must be admitted durably at the next **Safe Step Boundary**.
+- Nested project instruction discovery after successful reads remains a follow-up; when implemented, discovered instructions must be admitted durably at the next **Safe Provider-Turn Boundary**.
 - Location-scoped services naturally re-resolve effective context when a moved session next runs in its destination location.
 - Moving a Session clears its active **Context Epoch**, so the destination must initialize a complete baseline before another prompt can promote.
 - Instruction discovery, source identity, persistence, and file loading belong to the instruction service; the **System Context** abstraction only composes effectful producers and renders loaded values.
-- The first instruction-service slice observes global and upward project `AGENTS.md` files as one ordered aggregate **Context Source** at each **Safe Step Boundary**.
+- The first instruction-service slice observes global and upward project `AGENTS.md` files as one ordered aggregate **Context Source** at each **Safe Provider-Turn Boundary**.
 - Built-in and instruction context producers register through the **System Context Registry** with stable contribution keys. Plugin-defined context registration and hot-reload lifecycle remain a follow-up built on the same scoped registry seam.
 - Selected-agent available-skill guidance is a **Context Source** composed with Location-wide registry sources immediately before Context Epoch admission. It lists only names and descriptions permitted for that agent; skill bodies and locations are exposed only through the permission-checked `skill` tool.
-- The selected agent and model are sampled when a **Step** starts. Changes admitted after that boundary apply to the next Step and do not restart the current Step.
+- The selected agent and model are sampled when a provider turn starts. Changes admitted after that boundary apply to the next provider turn and do not restart the current turn.
 - Selected-agent available-skill guidance remains a **Context Source**. An agent switch that changes that guidance produces a **Mid-Conversation System Message** while preserving the current baseline.
-- Local tool authorization and pending permission requests retain the effective agent of the **Step** that issued the call; a later agent switch cannot change that call's policy.
-- Context source changes never wake idle sessions; the next naturally scheduled **Safe Step Boundary** loads and compares current values lazily.
-- Once admitted, a **Mid-Conversation System Message** remains durable even if the following **Physical Attempt** fails and is replayed unchanged on retry.
+- Local tool authorization and pending permission requests retain the effective agent of the provider turn that issued the call; a later agent switch cannot change that call's policy.
+- Context source changes never wake idle sessions; the next naturally scheduled **Safe Provider-Turn Boundary** loads and compares current values lazily.
+- Once admitted, a **Mid-Conversation System Message** remains durable even if the following provider attempt fails and is replayed unchanged on retry.
 - **Mid-Conversation System Messages** remain durable Session-message history; normal user-facing transcript surfaces may hide them.
 - The date **Context Source** initially preserves host-local calendar-date behavior; a configured user timezone may replace that default later.
 - A **Context Epoch** begins with one immutable **Baseline System Context**.
 - A **Baseline System Context** is stored durably and reused verbatim across process restarts within its **Context Epoch**.
 - A **Baseline System Context** durably preserves the exact joined text used for the active provider-cache prefix.
-- Completed compaction starts a new **Context Epoch** on the next **Physical Attempt**, folding the current complete **System Context** into a fresh baseline and removing earlier **Mid-Conversation System Messages** from active model history.
-- A model/provider switch preserves the current **Context Epoch** and chronological conversation history; the new selection applies to the next **Step**.
-- **Native Continuation Metadata** remains in durable history. Step projection includes it only for a successful exact originating provider/model match; failed Steps and incompatible models omit opaque metadata, while non-empty visible reasoning lowers to ordinary assistant text after a model switch. This conservative relation may widen only when recorded provider tests establish compatibility.
+- Completed compaction starts a new **Context Epoch** on the next provider attempt, folding the current complete **System Context** into a fresh baseline and removing earlier **Mid-Conversation System Messages** from active model history.
+- A model/provider switch preserves the current **Context Epoch** and chronological conversation history; the new selection applies to the next provider turn.
+- **Native Continuation Metadata** remains in durable history. Provider-turn projection includes it only for a successful exact originating provider/model match; failed turns and incompatible models omit opaque metadata, while non-empty visible reasoning lowers to ordinary assistant text after a model switch. This conservative relation may widen only when recorded provider tests establish compatibility.
 - **Model Request Options** remain provider-semantic through Catalog resolution. The Session runner maps them into the LLM package's provider-option namespace; the selected protocol adapter alone owns provider wire encoding.
 - **Generation Controls**, protocol-semantic **Model Request Options**, and compatibility request body fields are separate Catalog domains. A shared ingestion adapter partitions legacy and models.dev AI-SDK-shaped options before routing.
 - The **PTY Environment** is a server concern rather than a Core PTY concern. PTY creation merges caller values, then the host overlay, then Core-forced terminal invariants such as `TERM` and `OPENCODE_TERMINAL`.

package.json

@@ -14,8 +14,6 @@
     "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "lint": "oxlint",
-    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/core/src packages/server/src packages/protocol/src packages/cli/src",
-    "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
     "typecheck": "bun turbo typecheck",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
@@ -42,9 +40,9 @@
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.4.3",
-      "@opentui/keymap": "0.4.3",
-      "@opentui/solid": "0.4.3",
+      "@opentui/core": "0.3.4",
+      "@opentui/keymap": "0.3.4",
+      "@opentui/solid": "0.3.4",
       "@tanstack/solid-virtual": "3.13.28",
       "@shikijs/stream": "4.2.0",
       "ulid": "3.0.1",
@@ -97,7 +95,6 @@
   },
   "devDependencies": {
     "@actions/artifact": "5.0.1",
-    "@ast-grep/cli": "0.44.0",
     "@tsconfig/bun": "catalog:",
     "@types/mime-types": "3.0.1",
     "@typescript/native-preview": "catalog:",

packages/app/src/components/dialog-custom-provider.tsx

@@ -177,7 +177,7 @@ export function DialogCustomProvider(props: Props) {
     >
       <div class="flex flex-col gap-6 px-2.5 pb-3 overflow-y-auto max-h-[60vh]">
         <div class="px-2.5 flex gap-4 items-center">
-          <ProviderIcon id="session.synthetic" class="size-5 shrink-0 icon-strong-base" />
+          <ProviderIcon id="synthetic" class="size-5 shrink-0 icon-strong-base" />
           <div class="text-16-medium text-text-strong">{language.t("provider.custom.title")}</div>
         </div>
 

packages/app/src/components/settings-providers.tsx

@@ -226,7 +226,7 @@ const SettingsProvidersContent: Component = () => {
             >
               <div class="flex flex-col min-w-0">
                 <div class="flex flex-wrap items-center gap-x-3 gap-y-1">
-                  <ProviderIcon id="session.synthetic" class="size-5 shrink-0 icon-strong-base" />
+                  <ProviderIcon id="synthetic" class="size-5 shrink-0 icon-strong-base" />
                   <span class="text-14-medium text-text-strong">{language.t("provider.custom.title")}</span>
                   <Tag>{language.t("settings.providers.tag.custom")}</Tag>
                 </div>

packages/app/src/components/settings-v2/providers.tsx

@@ -223,7 +223,7 @@ export const SettingsProvidersV2: Component = () => {
             <div class="settings-v2-provider-row" data-component="custom-provider-section">
               <div class="settings-v2-provider-lead">
                 <ProviderIcon
-                  id="session.synthetic"
+                  id="synthetic"
                   width={PROVIDER_ICON_SIZE}
                   height={PROVIDER_ICON_SIZE}
                   class="settings-v2-provider-icon shrink-0"

packages/app/src/context/file/watcher.test.ts

@@ -7,7 +7,7 @@ describe("file watcher invalidation", () => {
     const refresh: string[] = []
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src/new.ts",
           event: "add",
@@ -32,7 +32,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src/open.ts",
           event: "change",
@@ -63,7 +63,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src",
           event: "change",
@@ -81,7 +81,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src/file.ts",
           event: "change",
@@ -111,7 +111,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: ".git/index.lock",
           event: "change",

packages/app/src/context/file/watcher.ts

@@ -16,7 +16,7 @@ type WatcherOps = {
 }
 
 export function invalidateFromWatcher(event: WatcherEvent, ops: WatcherOps) {
-  if (event.type !== "filesystem.changed") return
+  if (event.type !== "file.watcher.updated") return
   const props =
     typeof event.properties === "object" && event.properties ? (event.properties as Record<string, unknown>) : undefined
   const rawPath = typeof props?.file === "string" ? props.file : undefined

packages/app/src/pages/session.tsx

@@ -820,7 +820,7 @@ export default function Page() {
   )
 
   const stopVcs = sdk().event.listen((evt) => {
-    if (evt.details.type !== "filesystem.changed") return
+    if (evt.details.type !== "file.watcher.updated") return
     const props =
       typeof evt.details.properties === "object" && evt.details.properties
         ? (evt.details.properties as Record<string, unknown>)

packages/cli/package.json

@@ -10,46 +10,25 @@
   "files": [
     "bin"
   ],
-  "exports": {
-    "./daemon": "./src/daemon.ts",
-    "./mini": "./src/mini/index.ts",
-    "./mini/footer.command": "./src/mini/footer.command.tsx",
-    "./mini/footer.menu": "./src/mini/footer.menu.tsx",
-    "./mini/footer.permission": "./src/mini/footer.permission.tsx",
-    "./mini/footer.prompt": "./src/mini/footer.prompt.tsx",
-    "./mini/footer.question": "./src/mini/footer.question.tsx",
-    "./mini/footer.subagent": "./src/mini/footer.subagent.tsx",
-    "./mini/footer.view": "./src/mini/footer.view.tsx",
-    "./mini/scrollback.writer": "./src/mini/scrollback.writer.tsx",
-    "./mini/*": "./src/mini/*.ts",
-    "./server-process": "./src/server-process.ts"
-  },
   "scripts": {
     "build": "bun run script/build.ts",
     "dev": "bun run src/index.ts",
-    "test": "bun test --timeout 30000 --only-failures",
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/core": "workspace:*",
-    "@opencode-ai/plugin": "workspace:*",
-    "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/server": "workspace:*",
     "@opencode-ai/tui": "workspace:*",
     "@opentui/core": "catalog:",
-    "@opentui/keymap": "catalog:",
     "@opentui/solid": "catalog:",
     "@parcel/watcher": "2.5.1",
     "effect": "catalog:",
-    "fuzzysort": "catalog:",
     "jsonc-parser": "3.3.1",
-    "opentui-spinner": "catalog:",
     "semver": "catalog:",
-    "solid-js": "catalog:",
-    "strip-ansi": "7.1.2"
+    "solid-js": "catalog:"
   },
   "devDependencies": {
     "@opencode-ai/script": "workspace:*",

packages/cli/src/commands/commands.ts

@@ -3,31 +3,6 @@ import { Spec } from "../framework/spec"
 
 declare const OPENCODE_CLI_NAME: string | undefined
 
-const MiniParams = {
-  continue: Flag.boolean("continue").pipe(
-    Flag.withAlias("c"),
-    Flag.withDescription("Continue the last session"),
-    Flag.withDefault(false),
-  ),
-  session: Flag.string("session").pipe(
-    Flag.withAlias("s"),
-    Flag.withDescription("Session ID to continue"),
-    Flag.optional,
-  ),
-  fork: Flag.boolean("fork").pipe(
-    Flag.withDescription("Fork the session when continuing"),
-    Flag.withDefault(false),
-  ),
-  replay: Flag.boolean("replay").pipe(
-    Flag.withDescription("Replay session history on resume and after resize"),
-    Flag.withDefault(true),
-  ),
-  replayLimit: Flag.integer("replay-limit").pipe(
-    Flag.withDescription("Cap visible replay to the newest N messages"),
-    Flag.optional,
-  ),
-}
-
 export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
   description: "OpenCode 2.0 preview command line interface",
   params: {
@@ -113,86 +88,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       ],
     }),
     Spec.make("migrate", { description: "Migrate v1 data to v2" }),
-    Spec.make("mini", {
-      description: "Start the minimal interactive interface",
-      params: {
-        ...MiniParams,
-        project: Argument.string("project").pipe(
-          Argument.withDescription("Path to start OpenCode in"),
-          Argument.optional,
-        ),
-        model: Flag.string("model").pipe(
-          Flag.withAlias("m"),
-          Flag.withDescription("Model to use in the format provider/model"),
-          Flag.optional,
-        ),
-        agent: Flag.string("agent").pipe(Flag.withDescription("Agent to use"), Flag.optional),
-        prompt: Flag.string("prompt").pipe(Flag.withDescription("Prompt to use"), Flag.optional),
-        server: Flag.string("server").pipe(
-          Flag.withDescription("Connect to a server URL instead of the background service"),
-          Flag.optional,
-        ),
-        demo: Flag.boolean("demo").pipe(Flag.withDefault(false), Flag.withHidden),
-      },
-    }),
-    Spec.make("run", {
-      description: "Run OpenCode with a message",
-      params: {
-        message: Argument.string("message").pipe(
-          Argument.withDescription("Message to send"),
-          Argument.variadic({ min: 0 }),
-        ),
-        continue: Flag.boolean("continue").pipe(
-          Flag.withAlias("c"),
-          Flag.withDescription("Continue the last session"),
-          Flag.withDefault(false),
-        ),
-        session: Flag.string("session").pipe(
-          Flag.withAlias("s"),
-          Flag.withDescription("Session ID to continue"),
-          Flag.optional,
-        ),
-        fork: Flag.boolean("fork").pipe(
-          Flag.withDescription("Fork the session before continuing"),
-          Flag.withDefault(false),
-        ),
-        model: Flag.string("model").pipe(
-          Flag.withAlias("m"),
-          Flag.withDescription("Model to use in the format provider/model"),
-          Flag.optional,
-        ),
-        agent: Flag.string("agent").pipe(Flag.withDescription("Agent to use"), Flag.optional),
-        format: Flag.choice("format", ["default", "json"]).pipe(
-          Flag.withDescription("Output format"),
-          Flag.withDefault("default"),
-        ),
-        file: Flag.string("file").pipe(
-          Flag.withAlias("f"),
-          Flag.withDescription("File to attach to the message"),
-          Flag.atMost(100),
-        ),
-        title: Flag.string("title").pipe(Flag.withDescription("Session title"), Flag.optional),
-        server: Flag.string("server").pipe(
-          Flag.withDescription("Connect to a server URL instead of the background service"),
-          Flag.optional,
-        ),
-        dir: Flag.string("dir").pipe(Flag.withDescription("Directory to run in"), Flag.optional),
-        variant: Flag.string("variant").pipe(Flag.withDescription("Model variant"), Flag.optional),
-        thinking: Flag.boolean("thinking").pipe(
-          Flag.withDescription("Show thinking blocks"),
-          Flag.withDefault(false),
-        ),
-        auto: Flag.boolean("auto").pipe(
-          Flag.withDescription("Auto-approve permissions that are not explicitly denied"),
-          Flag.withDefault(false),
-        ),
-        yolo: Flag.boolean("yolo").pipe(Flag.withDefault(false), Flag.withHidden),
-        dangerouslySkipPermissions: Flag.boolean("dangerously-skip-permissions").pipe(
-          Flag.withDefault(false),
-          Flag.withHidden,
-        ),
-      },
-    }),
     Spec.make("service", {
       description: "Manage the background server",
       commands: [

packages/cli/src/commands/handlers/api.ts

@@ -4,6 +4,7 @@ import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { Service } from "@opencode-ai/client/effect"
 import { ServiceConfig } from "../../services/service-config"
+import type { Transport } from "@opencode-ai/client/effect"
 
 const methods = new Set(["delete", "get", "head", "options", "patch", "post", "put"])
 
@@ -60,7 +61,7 @@ export function rawRequest(input: readonly string[]) {
 }
 
 function resolveRequest(
-  transport: Service.Transport,
+  transport: Transport,
   input: readonly string[],
   params: Record<string, string>,
 ) {

packages/cli/src/commands/handlers/debug/agents.ts

@@ -1,5 +1,5 @@
 import { EOL } from "os"
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"

packages/cli/src/commands/handlers/default.ts

@@ -1,9 +1,9 @@
 import { NodeFileSystem } from "@effect/platform-node"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
-import { Effect, Option, Redacted } from "effect"
+import { Effect, Option } from "effect"
 import { Service } from "@opencode-ai/client/effect"
-import { Env } from "../../env"
+import type { Transport } from "@opencode-ai/client/effect"
 import { ServiceConfig } from "../../services/service-config"
 import { Standalone } from "../../services/standalone"
 import { Updater } from "../../services/updater"
@@ -19,29 +19,11 @@ export default Runtime.handler(Commands, (input) =>
       return yield* Effect.fail(new Error("--server and --standalone cannot be combined"))
     const transport = yield* Effect.gen(function* () {
       if (server !== undefined) {
-        const password = yield* Env.password
-        const explicit = {
+        const password = process.env["OPENCODE_SERVER_PASSWORD"]
+        return {
           url: server,
-          headers: password
-            ? { authorization: "Basic " + btoa("opencode:" + Redacted.value(password)) }
-            : undefined,
-        } satisfies Service.Transport
-        // Fail loudly before entering the TUI: an explicit server that is
-        // unreachable or rejects auth should not present as reconnect churn.
-        const response = yield* Effect.tryPromise(() =>
-          fetch(new URL("/api/health", server), { headers: explicit.headers, signal: AbortSignal.timeout(5_000) }),
-        ).pipe(Effect.mapError((cause) => new Error(`Could not reach server at ${server}`, { cause })))
-        if (response.status === 401)
-          return yield* Effect.fail(
-            new Error(
-              password
-                ? `Server at ${server} rejected the password`
-                : `Server at ${server} requires a password; set OPENCODE_PASSWORD`,
-            ),
-          )
-        if (!response.ok)
-          return yield* Effect.fail(new Error(`Server at ${server} responded with status ${response.status}`))
-        return explicit
+          headers: password ? { authorization: "Basic " + btoa("opencode:" + password) } : undefined,
+        } satisfies Transport
       }
       if (input.standalone) return yield* Standalone.transport()
       const options = yield* ServiceConfig.options()
@@ -54,36 +36,15 @@ export default Runtime.handler(Commands, (input) =>
     // retry the same address; for the managed service discovery re-reads the
     // registration and may start a replacement.
     const serviceOptions = server === undefined && !input.standalone ? yield* ServiceConfig.options() : undefined
-    // Only startup enforces the CLI version. A reconnect must accept a server
-    // replaced by another client or the two clients will restart it forever.
-    const reconnectOptions = serviceOptions ? { ...serviceOptions, version: undefined } : undefined
-    const discover = reconnectOptions
+    const discover = serviceOptions
       ? () =>
           Effect.runPromise(
             Effect.gen(function* () {
-              const found = yield* Service.discover(reconnectOptions)
-              return found ?? (yield* Service.start(reconnectOptions))
+              const found = yield* Service.discover(serviceOptions)
+              return found ?? (yield* Service.start(serviceOptions))
             }).pipe(Effect.provide(NodeFileSystem.layer)),
           )
       : () => Promise.resolve(transport)
-    // Restart the managed service in place; start() resolves once the
-    // replacement is healthy and the reconnect loop reattaches on its own.
-    // Only meaningful in service mode: --server is not ours to restart and a
-    // standalone child cannot be respawned.
-    const reload = serviceOptions
-      ? () =>
-          Effect.runPromise(
-            Effect.gen(function* () {
-              yield* Service.stop(serviceOptions)
-              yield* Service.start(serviceOptions)
-            }).pipe(Effect.provide(NodeFileSystem.layer)),
-          )
-      : undefined
-    yield* runTui(
-      transport,
-      { continue: input.continue, sessionID: Option.getOrUndefined(input.session) },
-      discover,
-      reload,
-    )
+    yield* runTui(transport, { continue: input.continue, sessionID: Option.getOrUndefined(input.session) }, discover)
   }),
 )

packages/cli/src/commands/handlers/mcp/list.ts

@@ -1,5 +1,5 @@
 import { EOL } from "node:os"
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { createOpencodeClient, type McpServer } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"

packages/cli/src/commands/handlers/migrate.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 

packages/cli/src/commands/handlers/mini.ts

@@ -1,35 +0,0 @@
-import { Effect, Option, Redacted } from "effect"
-import path from "node:path"
-import { Commands } from "../commands"
-import { Env } from "../../env"
-import { Runtime } from "../../framework/runtime"
-
-export default Runtime.handler(Commands.commands.mini, (input) =>
-  Effect.gen(function* () {
-    const { runMini } = yield* Effect.promise(() => import("../../mini"))
-    const project = Option.getOrUndefined(input.project)
-    const server = Option.getOrUndefined(input.server)
-    const password = yield* Env.password
-    yield* Effect.promise(() =>
-      runMini({
-        attach: server,
-        password: password ? Redacted.value(password) : undefined,
-        directory:
-          server !== undefined
-            ? project
-            : project === undefined
-              ? process.cwd()
-              : path.resolve(process.env.PWD ?? process.cwd(), project),
-        continue: input.continue,
-        session: Option.getOrUndefined(input.session),
-        fork: input.fork,
-        model: Option.getOrUndefined(input.model),
-        agent: Option.getOrUndefined(input.agent),
-        prompt: Option.getOrUndefined(input.prompt),
-        replay: input.replay,
-        replayLimit: Option.getOrUndefined(input.replayLimit),
-        demo: input.demo,
-      }),
-    )
-  }),
-)

packages/cli/src/commands/handlers/run.ts

@@ -1,31 +0,0 @@
-import { Effect, Option, Redacted } from "effect"
-import { Commands } from "../commands"
-import { Env } from "../../env"
-import { Runtime } from "../../framework/runtime"
-
-export default Runtime.handler(Commands.commands.run, (input) =>
-  Effect.gen(function* () {
-    const { runNonInteractive } = yield* Effect.promise(() => import("../../mini"))
-    const password = yield* Env.password
-    const separator = process.argv.indexOf("--", 2)
-    yield* Effect.promise(() =>
-      runNonInteractive({
-        message: [...input.message, ...(separator === -1 ? [] : process.argv.slice(separator + 1))],
-        continue: input.continue,
-        session: Option.getOrUndefined(input.session),
-        fork: input.fork,
-        model: Option.getOrUndefined(input.model),
-        agent: Option.getOrUndefined(input.agent),
-        format: input.format,
-        file: [...input.file],
-        title: Option.getOrUndefined(input.title),
-        server: Option.getOrUndefined(input.server),
-        password: password ? Redacted.value(password) : undefined,
-        directory: Option.getOrUndefined(input.dir),
-        variant: Option.getOrUndefined(input.variant),
-        thinking: input.thinking,
-        dangerouslySkipPermissions: input.auto || input.yolo || input.dangerouslySkipPermissions,
-      }),
-    )
-  }),
-)

packages/cli/src/commands/handlers/serve.ts

@@ -1,16 +1,145 @@
-import { Effect, Option } from "effect"
+import { NodeHttpServer } from "@effect/platform-node"
+import { Credential } from "@opencode-ai/core/credential"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { PermissionSaved } from "@opencode-ai/core/permission/saved"
+import { Global } from "@opencode-ai/core/global"
+import { Context, FileSystem, Layer, Option, Schedule, Schema } from "effect"
+import * as Effect from "effect/Effect"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
+import { createServer } from "node:http"
+import { createRoutes } from "@opencode-ai/server/routes"
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
-import { ServerProcess } from "../../server-process"
+import { ServiceConfig } from "../../services/service-config"
+import { Updater } from "../../services/updater"
+import { randomBytes, randomUUID } from "crypto"
+import path from "path"
 
 export default Runtime.handler(
   Commands.commands.serve,
   Effect.fn("cli.serve")(function* (input) {
-    if (input.service && input.stdio) return yield* Effect.fail(new Error("--service and --stdio cannot be combined"))
-    return yield* ServerProcess.run({
-      mode: input.service ? "service" : input.stdio ? "stdio" : "default",
-      hostname: Option.getOrUndefined(input.hostname),
-      port: Option.getOrUndefined(input.port),
-    })
+    if (input.service) yield* Effect.sync(() => process.chdir(Global.Path.home))
+    return yield* Effect.scoped(
+      Effect.gen(function* () {
+        const standalonePassword = process.env.OPENCODE_SERVER_PASSWORD
+        if (input.stdio) delete process.env.OPENCODE_SERVER_PASSWORD
+        const config = input.service ? yield* ServiceConfig.read() : {}
+        const password = input.service
+          ? yield* ServiceConfig.password()
+          : standalonePassword || randomBytes(32).toString("base64url")
+        if (!password) return yield* Effect.fail(new Error("Missing server password"))
+        const hostname = Option.getOrUndefined(input.hostname) ?? config.hostname ?? "127.0.0.1"
+        const port = Option.isSome(input.port)
+          ? input.port
+          : config.port === undefined
+            ? Option.none<number>()
+            : Option.some(config.port)
+        const address = yield* listen(hostname, port, password)
+        yield* Effect.tryPromise(() =>
+          createOpencodeClient({
+            baseUrl: HttpServer.formatAddress(address),
+            headers: ServerAuth.headers({ password }),
+          }).v2.health.get({}),
+        )
+        if (input.service) yield* register(address)
+        const url = HttpServer.formatAddress(address)
+        console.log(input.stdio ? JSON.stringify({ url }) : `server listening on ${url}`)
+        if (!input.service && !input.stdio && !standalonePassword) console.log(`server password ${password}`)
+        const updater = yield* Updater.Service
+        yield* updater.check().pipe(Effect.schedule(Schedule.spaced("10 minutes")), Effect.forkScoped)
+        return yield* (input.stdio ? waitForStdinClose() : Effect.never)
+      }).pipe(Effect.annotateLogs({ role: "server" })),
+    )
   }),
 )
+
+// Server-side half of the registration protocol. The registration embeds the
+// password so the file alone is enough for any client to discover and
+// authenticate. The file arbitrates ownership after concurrent starts; it is
+// not a startup lock: the atomic rename elects the latest writer, the watcher
+// self-evicts losers, and the finalizer id-guard keeps an exiting server from
+// deleting its successor's registration.
+const RegistrationId = Schema.Struct({ id: Schema.optional(Schema.String) })
+const decodeRegistrationId = Schema.decodeUnknownEffect(Schema.fromJsonString(RegistrationId))
+
+const register = Effect.fnUntraced(function* (address: HttpServer.Address) {
+  const fs = yield* FileSystem.FileSystem
+  const { file } = yield* ServiceConfig.options()
+  const id = randomUUID()
+  const secret = yield* ServiceConfig.password()
+  const temp = file + "." + id + ".tmp"
+  yield* fs.makeDirectory(path.dirname(file), { recursive: true })
+  yield* fs.writeFileString(
+    temp,
+    JSON.stringify({
+      id,
+      version: InstallationVersion,
+      url: HttpServer.formatAddress(address),
+      pid: process.pid,
+      password: secret,
+    }),
+    { mode: 0o600 },
+  )
+  yield* fs.rename(temp, file)
+  const currentID = fs.readFileString(file).pipe(
+    Effect.flatMap(decodeRegistrationId),
+    Effect.map((info) => info.id),
+    Effect.orElseSucceed(() => undefined),
+  )
+  yield* currentID.pipe(
+    Effect.flatMap((current) =>
+      current === id
+        ? Effect.void
+        : Effect.try({ try: () => process.kill(process.pid, "SIGTERM"), catch: (cause) => cause }).pipe(Effect.ignore),
+    ),
+    Effect.repeat(Schedule.spaced("10 seconds")),
+    Effect.forkScoped,
+  )
+  yield* Effect.addFinalizer(() =>
+    currentID.pipe(
+      Effect.flatMap((current) => (current === id ? fs.remove(file) : Effect.void)),
+      Effect.ignore,
+    ),
+  )
+})
+
+function waitForStdinClose() {
+  return Effect.callback<void>((resume) => {
+    const close = () => resume(Effect.void)
+    process.stdin.once("end", close)
+    process.stdin.once("close", close)
+    process.stdin.resume()
+    if (process.stdin.readableEnded || process.stdin.destroyed) close()
+    return Effect.sync(() => {
+      process.stdin.off("end", close)
+      process.stdin.off("close", close)
+      process.stdin.pause()
+    })
+  })
+}
+
+function listen(hostname: string, port: Option.Option<number>, password: string) {
+  if (Option.isSome(port)) return bind(hostname, port.value, password)
+  const next = (port: number): ReturnType<typeof bind> =>
+    bind(hostname, port, password).pipe(
+      Effect.catch((error) => (port === 65_535 ? Effect.fail(error) : next(port + 1))),
+    )
+  return next(4096)
+}
+
+function bind(hostname: string, port: number, password: string) {
+  const server = createServer()
+  return Layer.build(
+    HttpRouter.serve(createRoutes(password), { disableListenLog: true, disableLogger: true }).pipe(
+      Layer.provideMerge(NodeHttpServer.layer(() => server, { port, host: hostname })),
+      Layer.provide(AppNodeBuilder.build(LayerNode.group([Credential.node, PermissionSaved.node]))),
+    ),
+  ).pipe(
+    Effect.tap(() => Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()))),
+    Effect.map((context) => Context.get(context, HttpServer.HttpServer).address),
+  )
+}

packages/cli/src/commands/handlers/service/get.ts

@@ -1,5 +1,6 @@
 import { EOL } from "os"
-import { Effect, Option } from "effect"
+import { Option } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"

packages/cli/src/commands/handlers/service/restart.ts

@@ -1,5 +1,5 @@
 import { EOL } from "os"
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Service } from "@opencode-ai/client/effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"

packages/cli/src/commands/handlers/service/set.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"

packages/cli/src/commands/handlers/service/start.ts

@@ -1,5 +1,5 @@
 import { EOL } from "os"
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Service } from "@opencode-ai/client/effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"

packages/cli/src/commands/handlers/service/status.ts

@@ -1,5 +1,5 @@
 import { EOL } from "os"
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Service } from "@opencode-ai/client/effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"

packages/cli/src/commands/handlers/service/stop.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Service } from "@opencode-ai/client/effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"

packages/cli/src/commands/handlers/service/unset.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"

packages/cli/src/daemon.ts

@@ -1,70 +0,0 @@
-import { Service } from "@opencode-ai/client/effect"
-import { ClientError, isUnauthorizedError, OpenCode } from "@opencode-ai/client/promise"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { ServerAuth } from "@opencode-ai/server/auth"
-import { Effect } from "effect"
-import { ServiceConfig } from "./services/service-config"
-
-export type SharedOptions = {
-  readonly mode: "shared"
-  readonly command?: ReadonlyArray<string>
-}
-export type AttachOptions = {
-  readonly mode: "attach"
-  readonly url: string
-  readonly username?: string
-  readonly password?: string
-}
-export type Options = SharedOptions | AttachOptions
-
-const attach = Effect.fn("cli.daemon.attach")(function* (options: AttachOptions) {
-  const transport = {
-    url: options.url,
-    headers:
-      options.password === undefined
-        ? undefined
-        : ServerAuth.headers({ password: options.password, username: options.username }),
-  } satisfies Service.Transport
-  const client = OpenCode.make({ baseUrl: transport.url, headers: transport.headers })
-  const health = yield* Effect.tryPromise({
-    try: () => client.health.get({ signal: AbortSignal.timeout(5_000) }),
-    catch: (cause) => attachError(options, cause),
-  })
-  if (health.version !== InstallationVersion)
-    process.stderr.write(
-      `Warning: Server at ${options.url} has version ${health.version}; this client is ${InstallationVersion}. Continuing anyway.\n`,
-    )
-  return transport
-})
-
-const shared = Effect.fn("cli.daemon.shared")(function* (options: SharedOptions) {
-  const config = yield* ServiceConfig.options()
-  const service = options.command === undefined ? config : { ...config, command: options.command }
-  const found = yield* Service.discover(service)
-  if (found) return found
-  return yield* Service.start(service)
-})
-
-export function transport(options: AttachOptions): ReturnType<typeof attach>
-export function transport(options: SharedOptions): ReturnType<typeof shared>
-export function transport(options: Options): ReturnType<typeof attach> | ReturnType<typeof shared>
-export function transport(options: Options) {
-  if (options.mode === "attach") return attach(options)
-  return shared(options)
-}
-
-function attachError(options: AttachOptions, cause: unknown) {
-  if (isUnauthorizedError(cause)) {
-    return new Error(
-      options.password === undefined
-        ? `Server at ${options.url} requires authentication; provide a password`
-        : `Server at ${options.url} rejected the supplied credentials`,
-      { cause },
-    )
-  }
-  if (cause instanceof ClientError && cause.reason === "Transport")
-    return new Error(`Could not reach server at ${options.url}`, { cause })
-  return new Error(`Server at ${options.url} did not provide a compatible V2 health response`, { cause })
-}
-
-export * as Daemon from "./daemon"

packages/cli/src/env.ts

@@ -1,15 +0,0 @@
-import { Config } from "effect"
-
-// Every environment variable the CLI reads, in one place. Consumers yield
-// these instead of touching process.env so the full surface stays visible,
-// typed, and redacted where secret.
-
-// The opencode server password: sent by clients connecting to an explicit
-// --server, and adopted by a manually run or standalone server. The legacy
-// name is still honored.
-export const password = Config.redacted("OPENCODE_PASSWORD").pipe(
-  Config.orElse(() => Config.redacted("OPENCODE_SERVER_PASSWORD")),
-  Config.withDefault(undefined),
-)
-
-export * as Env from "./env"

packages/cli/src/framework/runtime.ts

@@ -1,8 +1,9 @@
-import { Effect, FileSystem, Scope } from "effect"
-import { Command } from "effect/unstable/cli"
+import * as Effect from "effect/Effect"
+import * as Command from "effect/unstable/cli/Command"
 import { Spec } from "./spec"
 import { Global } from "@opencode-ai/core/global"
 import { Updater } from "../services/updater"
+import { FileSystem, Scope } from "effect"
 
 export type Input<Value> =
   Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
@@ -11,21 +12,11 @@ export type Input<Value> =
       ? Input
       : never
 
-type RuntimeHandler = (
-  input: unknown,
-) => Effect.Effect<void, unknown, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
+type RuntimeHandler = (input: unknown) => Effect.Effect<void, unknown, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
 type Loader<Node extends Spec.Any> = () => Promise<{
-  default: (
-    input: Input<Node>,
-  ) => Effect.Effect<void, any, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
+  default: (input: Input<Node>) => Effect.Effect<void, any, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
 }>
-type ProvidedCommand = Command.Command<
-  string,
-  unknown,
-  unknown,
-  unknown,
-  FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope
->
+type ProvidedCommand = Command.Command<string, unknown, unknown, unknown, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
 
 export type Handlers<Node extends Spec.Any> = keyof Node["commands"] extends never
   ? Loader<Node>

packages/cli/src/framework/spec.ts

@@ -1,4 +1,4 @@
-import { Command } from "effect/unstable/cli"
+import * as Command from "effect/unstable/cli/Command"
 
 type Options<Config extends Command.Command.Config, Commands extends ReadonlyArray<Any>> = {
   readonly description?: string

packages/cli/src/index.ts

@@ -1,7 +1,10 @@
 #!/usr/bin/env bun
 
-import { NodeFileSystem, NodeRuntime, NodeServices } from "@effect/platform-node"
-import { Effect, Layer, Logger, References } from "effect"
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import { NodeFileSystem } from "@effect/platform-node"
+import * as Effect from "effect/Effect"
+import { Layer, Logger, References } from "effect"
 import { Commands } from "./commands/commands"
 import { Runtime } from "./framework/runtime"
 import { Logging } from "@opencode-ai/core/observability/logging"
@@ -31,8 +34,6 @@ const Handlers = Runtime.handlers(Commands, {
     logout: () => import("./commands/handlers/mcp/logout"),
   },
   migrate: () => import("./commands/handlers/migrate"),
-  mini: () => import("./commands/handlers/mini"),
-  run: () => import("./commands/handlers/run"),
   service: {
     start: () => import("./commands/handlers/service/start"),
     restart: () => import("./commands/handlers/service/restart"),
@@ -45,12 +46,7 @@ const Handlers = Runtime.handlers(Commands, {
   serve: () => import("./commands/handlers/serve"),
 })
 
-Effect.logInfo("cli starting", {
-  version: InstallationVersion,
-  channel: InstallationChannel,
-  local: InstallationLocal,
-  args: process.argv.slice(2),
-}).pipe(
+Effect.logInfo("cli starting", { version: InstallationVersion, channel: InstallationChannel, local: InstallationLocal }).pipe(
   Effect.flatMap(() => Runtime.run(Commands, Handlers, { version: InstallationVersion })),
   Effect.annotateLogs({ role: "cli" }),
   Effect.provide(Updater.layer),
@@ -58,6 +54,6 @@ Effect.logInfo("cli starting", {
   Effect.provide(LoggingLayer),
   Effect.provide(NodeServices.layer),
   Effect.scoped,
-  Effect.tap(() => Effect.sync(() => process.exit(process.exitCode ?? 0))),
+  Effect.tap(() => Effect.sync(() => process.exit(0))),
   NodeRuntime.runMain,
 )

packages/cli/src/mini/index.ts

@@ -1,7 +0,0 @@
-export { runMini, mergeInput as mergeInteractiveInput, type MiniCommandInput } from "./mini"
-export {
-  runNonInteractive,
-  mergeInput as mergeNonInteractiveInput,
-  pickRunModel,
-  type RunCommandInput,
-} from "./run"

packages/cli/src/mini/mini.ts

@@ -1,234 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
-import { truthy } from "@opencode-ai/core/flag/flag"
-import { Global } from "@opencode-ai/core/global"
-import { Effect } from "effect"
-import path from "node:path"
-import { Daemon } from "../daemon"
-import { waitForCatalogReady } from "./catalog.shared"
-import { INTERACTIVE_INPUT_ERROR, resolveInteractiveStdin } from "./runtime.stdin"
-import type { RunInput, RunTuiConfig } from "./types"
-
-export type MiniCommandInput = {
-  directory?: string
-  attach?: string
-  password?: string
-  username?: string
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: string
-  agent?: string
-  prompt?: string
-  replay?: boolean
-  replayLimit?: number
-  demo?: boolean
-  serverCommand?: ReadonlyArray<string>
-  tuiConfig?: RunTuiConfig | Promise<RunTuiConfig>
-}
-
-type Session = Awaited<ReturnType<OpenCodeClient["session"]["get"]>>
-type Transport = { readonly url: string; readonly headers?: HeadersInit }
-
-export async function runMini(input: MiniCommandInput) {
-  validate(input)
-  const initialInput = mergeInput(process.stdin.isTTY ? undefined : await Bun.stdin.text(), input.prompt)
-  const runtimeTask = import("./runtime")
-  const directory = input.attach ? input.directory : localDirectory(input.directory)
-  const transportTask = startTransport(input)
-  void transportTask.catch(() => {})
-
-  try {
-    if (input.attach) await transportTask
-    const sdk = OpenCode.make({
-      baseUrl: "http://opencode.pending",
-      fetch: deferredFetch(transportTask),
-    })
-    const attachedSession =
-      input.attach && input.session && !input.directory
-        ? await sdk.session.get({ sessionID: input.session }).catch(() => fail("Session not found"))
-        : undefined
-    const resolvedDirectory =
-      directory ?? attachedSession?.location.directory ?? (await remoteDirectory(await transportTask, sdk))
-    const model = parseModel(input.model)
-    let agentTask: Promise<string | undefined> | undefined
-    const resolveAgent = () => {
-      agentTask ??= validateAgent(sdk, resolvedDirectory, input.agent, input.attach)
-      return agentTask
-    }
-    const resolveSession = async () => {
-      const [agent, selected] = await Promise.all([
-        resolveAgent(),
-        selectSession(sdk, resolvedDirectory, input, attachedSession),
-      ])
-      const readyModel =
-        model ?? (selected?.model ? { providerID: selected.model.providerID, modelID: selected.model.id } : undefined)
-      if (readyModel) await waitForCatalogReady({ sdk, directory: resolvedDirectory, model: readyModel })
-      const session = selected ?? (await createSession(sdk, resolvedDirectory, agent, model))
-      return { id: session.id, title: session.title, resume: selected !== undefined }
-    }
-    const create = (
-      _sdk: OpenCodeClient,
-      next: { agent: string | undefined; model: RunInput["model"]; variant: string | undefined },
-    ) => createSession(sdk, resolvedDirectory, next.agent, next.model, next.variant)
-    const runtime = await runtimeTask
-    await runtime.runInteractiveDeferredMode({
-      sdk,
-      directory: resolvedDirectory,
-      resolveAgent,
-      session: resolveSession,
-      createSession: create,
-      agent: input.agent,
-      model,
-      variant: undefined,
-      files: [],
-      initialInput,
-      thinking: true,
-      backgroundSubagents:
-        truthy("OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS") ||
-        (process.env.OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS === undefined && truthy("OPENCODE_EXPERIMENTAL")),
-      replay: input.replay ?? true,
-      replayLimit: input.replayLimit,
-      demo: input.demo,
-      tuiConfig: input.tuiConfig,
-    })
-  } catch (error) {
-    if (error instanceof Error && error.message === INTERACTIVE_INPUT_ERROR) fail(error.message)
-    throw error
-  }
-}
-
-/** @internal Exported for testing. */
-export function mergeInput(piped: string | undefined, prompt: string | undefined) {
-  if (!prompt) return piped || undefined
-  if (!piped) return prompt
-  return piped + "\n" + prompt
-}
-
-function validate(input: MiniCommandInput) {
-  if (!process.stdout.isTTY) fail("opencode mini requires a TTY stdout")
-  if (input.replayLimit !== undefined && (!Number.isInteger(input.replayLimit) || input.replayLimit <= 0)) {
-    fail("--replay-limit must be a positive integer")
-  }
-  if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
-  resolveInteractiveStdin().cleanup?.()
-}
-
-function localDirectory(directory?: string): string {
-  const root = process.env.PWD ?? process.cwd()
-  try {
-    process.chdir(directory ? (path.isAbsolute(directory) ? directory : path.join(root, directory)) : root)
-    return process.cwd()
-  } catch {
-    fail(`Failed to change directory to ${directory}`)
-  }
-}
-
-function startTransport(input: MiniCommandInput): Promise<Transport> {
-  if (input.attach) {
-    return Effect.runPromise(
-      Daemon.transport({
-        mode: "attach",
-        url: input.attach,
-        password: input.password ?? process.env.OPENCODE_SERVER_PASSWORD,
-        username: input.username ?? process.env.OPENCODE_SERVER_USERNAME,
-      }),
-    )
-  }
-  return Effect.runPromise(
-    Daemon.transport({ mode: "shared", command: input.serverCommand }).pipe(
-      Effect.provide(NodeFileSystem.layer),
-      Effect.provide(Global.layerWith({})),
-    ),
-  )
-}
-
-function deferredFetch(transportTask: Promise<{ url: string; headers?: HeadersInit }>): typeof globalThis.fetch {
-  const fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-    const transport = await transportTask
-    const request = new Request(input, init)
-    const source = new URL(request.url)
-    const headers = new Headers(request.headers)
-    for (const [key, value] of new Headers(transport.headers)) headers.set(key, value)
-    return globalThis.fetch(new Request(new URL(source.pathname + source.search, transport.url), request), { headers })
-  }
-  return fetch as typeof globalThis.fetch
-}
-
-async function remoteDirectory(
-  transport: { url: string; headers?: HeadersInit },
-  sdk: OpenCodeClient,
-): Promise<string> {
-  const location = await sdk.location.get()
-  if (!location.directory) throw new Error(`Failed to resolve remote directory from ${transport.url}`)
-  return location.directory
-}
-
-function parseModel(value?: string): RunInput["model"] {
-  if (!value) return
-  const [providerID, ...rest] = value.split("/")
-  const modelID = rest.join("/")
-  if (!providerID || !modelID) fail("--model must use the format provider/model")
-  return { providerID, modelID }
-}
-
-async function validateAgent(sdk: OpenCodeClient, directory: string, name?: string, attach?: string) {
-  if (!name) return
-  const deadline = Date.now() + 5_000
-  let agents: Awaited<ReturnType<OpenCodeClient["agent"]["list"]>> | undefined
-  while (Date.now() < deadline) {
-    agents = await sdk.agent.list({ location: { directory } }).catch(() => undefined)
-    const agent = agents?.data.find((item) => item.id === name)
-    if (agent?.mode === "subagent") {
-      warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
-      return
-    }
-    if (agent) return name
-    await Bun.sleep(25)
-  }
-  if (!agents) {
-    warning(`failed to list agents${attach ? ` from ${attach}` : ""}. Falling back to default agent`)
-    return
-  }
-  warning(`agent "${name}" not found. Falling back to default agent`)
-}
-
-async function selectSession(sdk: OpenCodeClient, directory: string, input: MiniCommandInput, preselected?: Session) {
-  const selected =
-    preselected ??
-    (input.session
-      ? await sdk.session.get({ sessionID: input.session }).catch(() => undefined)
-      : input.continue
-        ? await sdk.session
-            .list({ directory, parentID: null, limit: 1, order: "desc" })
-            .then((result) => result.data[0])
-        : undefined)
-  if (input.session && !selected) fail("Session not found")
-  if (!selected) return
-  if (!input.fork) return selected
-  return sdk.session.fork({ sessionID: selected.id })
-}
-
-async function createSession(
-  sdk: OpenCodeClient,
-  directory: string,
-  agent: string | undefined,
-  model: RunInput["model"],
-  variant?: string,
-): Promise<Session> {
-  if (model) await waitForCatalogReady({ sdk, directory, model })
-  return sdk.session.create({
-    agent,
-    model: model ? { providerID: model.providerID, id: model.modelID, variant } : undefined,
-    location: { directory },
-  })
-}
-
-function warning(message: string) {
-  process.stderr.write(`\x1b[93m\x1b[1m!\x1b[0m ${message}\n`)
-}
-
-function fail(message: string): never {
-  process.stderr.write(`\x1b[91m\x1b[1mError: \x1b[0m${message}\n`)
-  process.exit(1)
-}

packages/cli/src/mini/run.ts

@@ -1,311 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
-import { Global } from "@opencode-ai/core/global"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import type { ToolPart } from "@opencode-ai/sdk/v2"
-import { Effect } from "effect"
-import { open } from "node:fs/promises"
-import path from "node:path"
-import { Daemon } from "../daemon"
-import { Standalone } from "../services/standalone"
-import { loadRunAgents, waitForCatalogReady } from "./catalog.shared"
-import { runNonInteractivePrompt } from "./noninteractive"
-import { toolInlineInfo } from "./tool"
-import { UI } from "./ui"
-
-export type RunCommandInput = {
-  message: string[]
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: string
-  agent?: string
-  format: "default" | "json"
-  file: string[]
-  title?: string
-  server?: string
-  password?: string
-  username?: string
-  directory?: string
-  variant?: string
-  thinking?: boolean
-  dangerouslySkipPermissions?: boolean
-  standaloneCommand?: ReadonlyArray<string>
-}
-
-type FilePart = {
-  url: string
-  filename: string
-  mime: string
-}
-
-type Transport = { readonly url: string; readonly headers?: HeadersInit }
-
-type Prepared = {
-  directory?: string
-  message: string
-  files: FilePart[]
-}
-
-const ATTACH_FILE_MAX_BYTES = 10 * 1024 * 1024
-
-export function runNonInteractive(input: RunCommandInput) {
-  return run(input).catch((error) => reportError(input, error instanceof Error ? error.message : String(error)))
-}
-
-async function run(input: RunCommandInput) {
-  if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
-  const root = process.env.PWD ?? process.cwd()
-  const directory = input.server ? input.directory : localDirectory(input.directory, root)
-  const message = mergeInput(formatMessage(input.message), process.stdin.isTTY ? undefined : await Bun.stdin.text())
-  if (!message?.trim()) fail("You must provide a message")
-  const files = await Promise.all(
-    input.file.map((file) => prepareFile(file, input.server ? root : (directory ?? root), input.server !== undefined)),
-  )
-  const prepared = { directory, message, files }
-  if (input.standaloneCommand)
-    return Effect.runPromise(
-      Effect.scoped(
-        Effect.gen(function* () {
-          const transport = yield* Standalone.transport({ command: input.standaloneCommand })
-          yield* Effect.promise(() => execute(input, prepared, transport))
-        }),
-      ),
-    )
-  const transport = await startTransport(input)
-  return execute(input, prepared, transport)
-}
-
-async function execute(input: RunCommandInput, prepared: Prepared, transport: Transport) {
-  const client = OpenCode.make({ baseUrl: transport.url, headers: transport.headers })
-  const requestedDirectory = prepared.directory ?? (await client.location.get()).directory
-  if (!requestedDirectory) fail("Failed to resolve server directory")
-  const session = await selectSession(client, requestedDirectory, input)
-  const cwd = session?.location.directory ?? requestedDirectory
-  const workspace = session?.location.workspaceID
-  const explicitModel = parseModel(input.model)
-  const sessionModel = session?.model ? { providerID: session.model.providerID, modelID: session.model.id } : undefined
-  const defaultModel =
-    !explicitModel && !sessionModel
-      ? await client.model
-          .default({ location: { directory: cwd, workspace } })
-          .then((result) =>
-            result.data ? { providerID: result.data.providerID, modelID: result.data.id } : undefined,
-          )
-      : undefined
-  const model = pickRunModel(explicitModel, input.variant, sessionModel, defaultModel)
-  if (input.variant && !model) return reportError(input, "Cannot select a variant before selecting a model", session?.id)
-  if (model) {
-    await waitForCatalogReady({ sdk: client, directory: cwd, workspace, model })
-    const available = await client.model.list({ location: { directory: cwd, workspace } })
-    if (!available.data.some((item) => item.providerID === model.providerID && item.id === model.modelID))
-      return reportError(input, `Model unavailable: ${model.providerID}/${model.modelID}`, session?.id)
-  }
-  const agent = await validateAgent(client, cwd, input.agent, input.server)
-  const selected =
-    session ??
-    (await client.session.create({
-      agent,
-      model: model ? { providerID: model.providerID, id: model.modelID, variant: input.variant } : undefined,
-      location: { directory: cwd },
-    }))
-  if (!session && input.title !== undefined) {
-    await client.session.rename({
-      sessionID: selected.id,
-      title:
-        input.title ||
-        prepared.message.slice(0, 50) + (prepared.message.length > 50 ? "..." : ""),
-    })
-  }
-
-  await runNonInteractivePrompt({
-    client,
-    sessionID: selected.id,
-    message: prepared.message,
-    files: prepared.files,
-    agent,
-    model,
-    variant: input.variant,
-    thinking: input.thinking ?? false,
-    format: input.format,
-    dangerouslySkipPermissions: input.dangerouslySkipPermissions ?? false,
-    attached: !input.standaloneCommand,
-    renderTool,
-    renderToolError,
-  }).catch((error) => reportError(input, error instanceof Error ? error.message : String(error), selected.id))
-}
-
-export function mergeInput(message: string | undefined, piped: string | undefined) {
-  if (!message) return piped || undefined
-  if (!piped) return message
-  return message + "\n" + piped
-}
-
-export function pickRunModel(
-  explicit: { providerID: string; modelID: string } | undefined,
-  variant: string | undefined,
-  session: { providerID: string; modelID: string } | undefined,
-  fallback: { providerID: string; modelID: string } | undefined,
-) {
-  if (explicit) return explicit
-  if (!variant) return
-  return session ?? fallback
-}
-
-function formatMessage(message: string[]) {
-  const value = message.map((part) => (part.includes(" ") ? `"${part.replace(/"/g, '\\"')}"` : part)).join(" ")
-  return value || undefined
-}
-
-function localDirectory(directory: string | undefined, root: string) {
-  try {
-    process.chdir(directory ? (path.isAbsolute(directory) ? directory : path.join(root, directory)) : root)
-    return process.cwd()
-  } catch {
-    fail(`Failed to change directory to ${directory}`)
-  }
-}
-
-function startTransport(input: RunCommandInput) {
-  if (input.server) {
-    return Effect.runPromise(
-      Daemon.transport({
-        mode: "attach",
-        url: input.server,
-        password: input.password,
-        username: input.username,
-      }),
-    )
-  }
-  return Effect.runPromise(
-    Daemon.transport({ mode: "shared" }).pipe(
-      Effect.provide(NodeFileSystem.layer),
-      Effect.provide(Global.layerWith({})),
-    ),
-  )
-}
-
-function parseModel(value?: string) {
-  if (!value) return
-  const [providerID, ...rest] = value.split("/")
-  const modelID = rest.join("/")
-  if (!providerID || !modelID) fail("--model must use the format provider/model")
-  return { providerID, modelID }
-}
-
-async function validateAgent(client: OpenCodeClient, directory: string, name?: string, server?: string) {
-  if (!name) return
-  const agents = await loadRunAgents(client, directory).catch(() => undefined)
-  if (!agents) {
-    warning(`failed to list agents${server ? ` from ${server}` : ""}. Falling back to default agent`)
-    return
-  }
-  const agent = agents.find((item) => item.name === name)
-  if (!agent) {
-    warning(`agent "${name}" not found. Falling back to default agent`)
-    return
-  }
-  if (agent.mode === "subagent") {
-    warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
-    return
-  }
-  return name
-}
-
-async function selectSession(client: OpenCodeClient, directory: string, input: RunCommandInput) {
-  const selected = input.session
-    ? await client.session.get({ sessionID: input.session }).catch(() => undefined)
-    : input.continue
-      ? await client.session
-          .list({ directory, parentID: null, limit: 1, order: "desc" })
-          .then((result) => result.data[0])
-      : undefined
-  if (input.session && !selected) fail("Session not found")
-  if (!selected || !input.fork) return selected
-  return client.session.fork({ sessionID: selected.id })
-}
-
-async function prepareFile(input: string, directory: string, remote: boolean): Promise<FilePart> {
-  const file = path.resolve(directory, input)
-  const handle = await open(file, "r").catch(() => fail(`File not found: ${input}`))
-  try {
-    const stat = await handle.stat()
-    if (remote && stat.isDirectory()) fail(`Cannot attach local directory without a shared filesystem: ${input}`)
-    if (!stat.isFile() || stat.size > ATTACH_FILE_MAX_BYTES)
-      fail(`Cannot attach a directory, special file, or file larger than 10 MiB: ${input}`)
-    const content = Buffer.alloc(Number(stat.size))
-    let offset = 0
-    while (offset < content.length) {
-      const read = await handle.read(content, offset, content.length - offset, offset)
-      if (read.bytesRead === 0) break
-      offset += read.bytesRead
-    }
-    const bytes = content.subarray(0, offset)
-    const detected = FSUtil.mimeType(file)
-    const text = bytes.toString("utf8")
-    const mime =
-      detected.startsWith("image/") || detected === "application/pdf"
-        ? detected
-        : !isBinaryContent(bytes) && Buffer.from(text, "utf8").equals(bytes)
-          ? "text/plain"
-          : detected
-    return {
-      url: `data:${mime};base64,${bytes.toString("base64")}`,
-      filename: path.basename(file),
-      mime,
-    }
-  } finally {
-    await handle.close()
-  }
-}
-
-function isBinaryContent(bytes: Uint8Array) {
-  if (bytes.length === 0) return false
-  if (bytes.includes(0)) return true
-  return bytes.reduce((count, byte) => count + Number(byte < 9 || (byte > 13 && byte < 32)), 0) / bytes.length > 0.3
-}
-
-async function renderTool(part: ToolPart) {
-  const info = toolInlineInfo(part)
-  if (info.mode === "block") {
-    UI.empty()
-    UI.println(UI.Style.TEXT_NORMAL + info.icon, UI.Style.TEXT_NORMAL + info.title)
-    if (info.body?.trim()) UI.println(info.body)
-    UI.empty()
-    return
-  }
-  UI.println(
-    UI.Style.TEXT_NORMAL + info.icon,
-    UI.Style.TEXT_NORMAL + info.title,
-    info.description ? UI.Style.TEXT_DIM + info.description + UI.Style.TEXT_NORMAL : "",
-  )
-}
-
-async function renderToolError(part: ToolPart) {
-  const info = toolInlineInfo(part)
-  UI.println(UI.Style.TEXT_NORMAL + "✗", UI.Style.TEXT_NORMAL + `${info.title} failed`)
-}
-
-function warning(message: string) {
-  UI.println(UI.Style.TEXT_WARNING_BOLD + "!", UI.Style.TEXT_NORMAL, message)
-}
-
-function reportError(input: RunCommandInput, message: string, sessionID?: string) {
-  process.exitCode = 1
-  if (input.format === "json") {
-    process.stdout.write(
-      JSON.stringify({
-        type: "error",
-        timestamp: Date.now(),
-        sessionID: sessionID ?? "",
-        error: { type: "unknown", message },
-      }) + "\n",
-    )
-    return
-  }
-  UI.error(message)
-}
-
-function fail(message: string): never {
-  throw new Error(message)
-}

packages/cli/src/mini/ui.ts

@@ -1,27 +0,0 @@
-import { EOL } from "node:os"
-
-export const Style = {
-  TEXT_DIM: "\x1b[90m",
-  TEXT_NORMAL: "\x1b[0m",
-  TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
-  TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
-}
-
-export function println(...message: string[]) {
-  process.stderr.write(message.join(" ") + EOL)
-}
-
-let blank = false
-
-export function empty() {
-  if (blank) return
-  println(Style.TEXT_NORMAL)
-  blank = true
-}
-
-export function error(message: string) {
-  if (message.startsWith("Error: ")) message = message.slice("Error: ".length)
-  println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
-}
-
-export * as UI from "./ui"

packages/cli/src/server-process.ts

@@ -1,134 +0,0 @@
-export * as ServerProcess from "./server-process"
-
-import { NodeServices } from "@effect/platform-node"
-import { Service } from "@opencode-ai/client/effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { Global } from "@opencode-ai/core/global"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { AppProcess } from "@opencode-ai/core/process"
-import { Flock } from "@opencode-ai/core/util/flock"
-import { start } from "@opencode-ai/server/process"
-import { randomBytes, randomUUID } from "node:crypto"
-import path from "node:path"
-import { Effect, FileSystem, Logger, Option, Redacted, Schedule, Schema } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { Env } from "./env"
-import { ServiceConfig } from "./services/service-config"
-import { Updater } from "./services/updater"
-
-export type Mode = "default" | "service" | "stdio"
-
-export type Options = {
-  readonly mode: Mode
-  readonly hostname?: string
-  readonly port?: number
-}
-
-export const run = Effect.fn("cli.server-process.run")((options: Options) =>
-  processEffect(options).pipe(
-    Effect.provide(Updater.layer),
-    Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node]))),
-    Effect.provide(NodeServices.layer),
-  ),
-)
-
-const processEffect = Effect.fnUntraced(function* (options: Options) {
-  if (options.mode === "service") yield* Effect.sync(() => process.chdir(Global.Path.home))
-  return yield* Effect.scoped(
-    Effect.gen(function* () {
-      if (options.mode === "service") {
-        const service = yield* ServiceConfig.options()
-        yield* Flock.effect(path.basename(service.file, ".json") + "-process", {
-          dir: path.dirname(service.file),
-          staleMs: 3_000,
-          timeoutMs: 15_000,
-        })
-      }
-      const environmentPassword = yield* Env.password
-      // Keep the lease credential out of the environment inherited by tools.
-      if (options.mode === "stdio") {
-        delete process.env.OPENCODE_PASSWORD
-        delete process.env.OPENCODE_SERVER_PASSWORD
-      }
-      const config = options.mode === "service" ? yield* ServiceConfig.read() : {}
-      const password =
-        options.mode === "service"
-          ? yield* ServiceConfig.password()
-          : environmentPassword
-            ? Redacted.value(environmentPassword)
-            : randomBytes(32).toString("base64url")
-      if (!password) return yield* Effect.fail(new Error("Missing server password"))
-      const address = yield* start({
-        hostname: options.hostname ?? config.hostname ?? "127.0.0.1",
-        port: Option.fromNullishOr(options.port ?? config.port),
-        password,
-      }).pipe(Effect.provide(Logger.layer([], { mergeWithExisting: false })))
-      if (options.mode === "service") yield* register(address, password)
-      const url = HttpServer.formatAddress(address)
-      console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
-      if (options.mode === "default" && !environmentPassword) console.log(`server password ${password}`)
-      const updater = yield* Updater.Service
-      yield* updater.check().pipe(Effect.schedule(Schedule.spaced("10 minutes")), Effect.forkScoped)
-      return yield* options.mode === "stdio" ? waitForStdinClose() : Effect.never
-    }).pipe(Effect.annotateLogs({ role: "server" })),
-  )
-})
-
-// The latest atomic registration wins. A displaced process notices the new id,
-// exits, and cannot remove its successor's registration from its finalizer.
-const infoJson = Schema.fromJsonString(Service.Info)
-const encodeInfo = Schema.encodeEffect(infoJson)
-const decodeInfo = Schema.decodeUnknownEffect(infoJson)
-
-const register = Effect.fnUntraced(function* (address: HttpServer.Address, password: string) {
-  const fs = yield* FileSystem.FileSystem
-  const options = yield* ServiceConfig.options()
-  const id = randomUUID()
-  const temp = options.file + "." + id + ".tmp"
-  yield* fs.makeDirectory(path.dirname(options.file), { recursive: true })
-  const encoded = yield* encodeInfo({
-    id,
-    version: InstallationVersion,
-    url: HttpServer.formatAddress(address),
-    pid: process.pid,
-    password,
-  })
-  yield* fs.writeFileString(temp, encoded, { mode: 0o600 })
-  yield* fs.rename(temp, options.file)
-  const currentID = fs.readFileString(options.file).pipe(
-    Effect.flatMap(decodeInfo),
-    Effect.map((info) => info.id),
-    Effect.orElseSucceed(() => undefined),
-  )
-  yield* currentID.pipe(
-    Effect.flatMap((current) =>
-      current === id
-        ? Effect.void
-        : Effect.try({ try: () => process.kill(process.pid, "SIGTERM"), catch: (cause) => cause }).pipe(Effect.ignore),
-    ),
-    Effect.repeat(Schedule.spaced("10 seconds")),
-    Effect.forkScoped,
-  )
-  yield* Effect.addFinalizer(() =>
-    currentID.pipe(
-      Effect.flatMap((current) => (current === id ? fs.remove(options.file) : Effect.void)),
-      Effect.ignore,
-    ),
-  )
-})
-
-function waitForStdinClose() {
-  return Effect.callback<void>((resume) => {
-    const close = () => resume(Effect.void)
-    process.stdin.once("end", close)
-    process.stdin.once("close", close)
-    process.stdin.resume()
-    if (process.stdin.readableEnded || process.stdin.destroyed) close()
-    return Effect.sync(() => {
-      process.stdin.off("end", close)
-      process.stdin.off("close", close)
-      process.stdin.pause()
-    })
-  })
-}

packages/cli/src/services/service-config.ts

@@ -5,7 +5,7 @@ import { Effect, FileSystem, Schema } from "effect"
 import { randomBytes } from "crypto"
 import path from "path"
 
-// The CLI's service configuration file, plus the Service.Options binding that
+// The CLI's service configuration file, plus the ServiceOptions binding that
 // points the client package's service operations at this CLI: which
 // registration file (by channel), which version, and how to spawn opencode.
 

packages/cli/src/services/standalone.ts

@@ -9,21 +9,13 @@ import path from "node:path"
 const Ready = Schema.Struct({ url: Schema.String })
 const decodeReady = Schema.decodeUnknownPromise(Schema.fromJsonString(Ready))
 
-type Options = {
-  readonly command?: ReadonlyArray<string>
-}
-
-function command(password: string, options: Options) {
+function command(password: string) {
   const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
   const entrypoint = compiled ? [] : process.argv[1] ? [process.argv[1]] : []
   if (!compiled && entrypoint.length === 0) throw new Error("Failed to resolve CLI entrypoint")
-  const [executable, ...args] = options.command ?? [process.execPath, ...entrypoint, "serve"]
-  if (!executable) throw new Error("Failed to resolve standalone server command")
-  return ChildProcess.make(executable, [...args, "--stdio", "--port", "0"], {
+  return ChildProcess.make(process.execPath, [...entrypoint, "serve", "--stdio", "--port", "0"], {
     cwd: process.cwd(),
-    // Explicit entry wins over anything inherited, so a user-exported
-    // OPENCODE_PASSWORD cannot shadow the child's lease credential.
-    env: { OPENCODE_PASSWORD: password },
+    env: { OPENCODE_SERVER_PASSWORD: password },
     extendEnv: true,
     // The server treats EOF on this pipe as the end of its ownership lease.
     // The OS closes it even when the TUI is killed before Effect finalizers run.
@@ -34,21 +26,17 @@ function command(password: string, options: Options) {
   })
 }
 
-const makeTransport = Effect.fn("cli.standalone.transport")(
-  function* (options: Options) {
+export const transport = Effect.fn("cli.standalone.transport")(
+  function* () {
     const password = randomBytes(32).toString("base64url")
     const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-    const proc = yield* spawner.spawn(command(password, options))
+    const proc = yield* spawner.spawn(command(password))
     const output = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.take(1), Stream.mkString)
     if (!output) return yield* Effect.fail(new Error("Standalone server exited before reporting readiness"))
     const ready = yield* Effect.tryPromise(() => decodeReady(output))
-    return { url: ready.url, headers: ServerAuth.headers({ password, username: "opencode" }), pid: proc.pid }
+    return { url: ready.url, headers: ServerAuth.headers({ password }), pid: proc.pid }
   },
   Effect.provide(AppNodeBuilder.build(CrossSpawnSpawner.node)),
 )
 
-export function transport(options: Options = {}) {
-  return makeTransport(options)
-}
-
 export * as Standalone from "./standalone"

packages/cli/src/tui.ts

@@ -5,16 +5,11 @@ import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Global } from "@opencode-ai/core/global"
 import { loadBuiltinPlugins } from "@opencode-ai/tui/builtins"
 import { OpenCode } from "@opencode-ai/client/promise"
-import type { Service } from "@opencode-ai/client/effect"
+import type { Transport } from "@opencode-ai/client/effect"
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import type { Args } from "@opencode-ai/tui/context/args"
 
-export function runTui(
-  transport: Service.Transport,
-  args: Args,
-  discover?: () => Promise<Service.Transport>,
-  reload?: () => Promise<void>,
-) {
+export function runTui(transport: Transport, args: Args, discover?: () => Promise<Transport>) {
   const config = TuiConfig.resolve({}, { terminalSuspend: false })
   let disposeSlots: (() => void) | undefined
   return Effect.gen(function* () {
@@ -38,7 +33,6 @@ export function runTui(
             }
           }
         : undefined,
-      reload,
       args,
       config,
       pluginHost: {

packages/cli/test/fixture/standalone-owner.ts

@@ -8,8 +8,7 @@ await Effect.runPromise(
   Effect.scoped(
     Effect.gen(function* () {
       const transport = yield* Standalone.transport()
-      const response = yield* Effect.promise(() => fetch(new URL("/api/health", transport.url), { headers: transport.headers }))
-      console.log(`${transport.pid} ${transport.url} ${response.status}`)
+      console.log(`${transport.pid} ${transport.url}`)
       return yield* Effect.never
     }),
   ),

packages/cli/test/mini.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import path from "node:path"
-import { mergeInteractiveInput, mergeNonInteractiveInput, pickRunModel } from "../src/mini"
-
-async function cli(args: string[]) {
-  const child = Bun.spawn([process.execPath, "run", "src/index.ts", ...args], {
-    cwd: path.join(import.meta.dir, ".."),
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-    child.exited,
-  ])
-  return { stdout, stderr, exitCode }
-}
-
-describe("mini command", () => {
-  test("uses piped stdin as the initial prompt", () => {
-    expect(mergeInteractiveInput("from stdin", undefined)).toBe("from stdin")
-    expect(mergeInteractiveInput("from stdin", "from flag")).toBe("from stdin\nfrom flag")
-  })
-
-  test("keeps run as mini's non-interactive input mode", () => {
-    expect(mergeNonInteractiveInput("from args", "from stdin")).toBe("from args\nfrom stdin")
-    expect(mergeNonInteractiveInput(undefined, "from stdin")).toBe("from stdin")
-  })
-
-  test("applies a variant to a resumed session's model", () => {
-    expect(
-      pickRunModel(
-        undefined,
-        "high",
-        { providerID: "session-provider", modelID: "session-model" },
-        { providerID: "default-provider", modelID: "default-model" },
-      ),
-    ).toEqual({ providerID: "session-provider", modelID: "session-model" })
-  })
-
-  test("is registered in the preview CLI", async () => {
-    const result = await cli(["--help"])
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain("mini       Start the minimal interactive interface")
-    expect(result.stdout).toContain("run        Run OpenCode with a message")
-  })
-
-  test("exposes run without legacy attach or command modes", async () => {
-    const result = await cli(["run", "--help"])
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain("--server string")
-    expect(result.stdout).not.toContain("--attach")
-    expect(result.stdout).not.toContain("--command")
-  })
-
-  test("keeps option-like prompt text after the argument separator", async () => {
-    const result = await cli(["run", "--server", "http://127.0.0.1:1", "--", "--foo"])
-
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).not.toContain("You must provide a message")
-  })
-
-  test("preserves a run failure exit code", async () => {
-    let modelRequests = 0
-    const server = Bun.serve({
-      port: 0,
-      fetch(request) {
-        const url = new URL(request.url)
-        if (url.pathname === "/api/health")
-          return Response.json({ healthy: true, version: InstallationVersion, pid: process.pid })
-        if (url.pathname === "/api/model") {
-          modelRequests++
-          return Response.json({
-            location: { directory: process.cwd(), project: { id: "global", directory: process.cwd() } },
-            data: modelRequests === 1 ? [{ id: "missing", providerID: "definitely" }] : [],
-          })
-        }
-        return new Response(undefined, { status: 404 })
-      },
-    })
-
-    try {
-      const result = await cli([
-        "run",
-        "--server",
-        server.url.toString(),
-        "--dir",
-        process.cwd(),
-        "--model",
-        "definitely/missing",
-        "hi",
-      ])
-
-      expect(result.exitCode).toBe(1)
-      expect(result.stderr).toContain("Model unavailable: definitely/missing")
-    } finally {
-      server.stop(true)
-    }
-  })
-
-  test("reports pre-admission errors as JSON", async () => {
-    const server = Bun.serve({
-      port: 0,
-      fetch() {
-        return Response.json({ healthy: true, version: "incompatible", pid: process.pid })
-      },
-    })
-
-    try {
-      const result = await cli(["run", "--format", "json", "--server", server.url.toString(), "hi"])
-
-      expect(result.exitCode).toBe(1)
-      expect(JSON.parse(result.stdout)).toMatchObject({
-        type: "error",
-        sessionID: "",
-        error: { type: "unknown", message: "Failed to resolve server directory" },
-      })
-    } finally {
-      server.stop(true)
-    }
-  })
-
-  test("uses the shared V2 server option instead of an attach command", async () => {
-    const result = await cli(["mini", "--help"])
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain("--server string")
-    expect(result.stdout).not.toContain("SUBCOMMANDS")
-  })
-
-  test("routes local and explicit-server invocations into mini", async () => {
-    for (const args of [["mini"], ["mini", "--server", "http://127.0.0.1:1"]]) {
-      const result = await cli(args)
-
-      expect(result.exitCode).toBe(1)
-      expect(result.stderr).toContain("opencode mini requires a TTY stdout")
-    }
-  })
-})

packages/cli/test/standalone.test.ts

@@ -4,19 +4,18 @@ import path from "node:path"
 test("standalone server exits when its owner is killed", async () => {
   const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "fixture/standalone-owner.ts")], {
     cwd: path.join(import.meta.dir, ".."),
-    env: { ...process.env, OPENCODE_SERVER_USERNAME: "custom" },
+    env: process.env,
     stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
   })
   const line = await Promise.race([readLine(owner.stdout), Bun.sleep(10_000).then(() => undefined)])
-  const [rawPID, url, status] = line?.split(" ") ?? []
+  const [rawPID, url] = line?.split(" ") ?? []
   const pid = Number(rawPID)
 
   try {
     expect(pid).toBeGreaterThan(0)
     expect(url).toStartWith("http://127.0.0.1:")
-    expect(status).toBe("200")
     expect(running(pid)).toBe(true)
 
     owner.kill("SIGKILL")

packages/client/package.json

@@ -1,30 +1,16 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/client",
-  "version": "1.17.13",
+  "private": true,
   "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git",
-    "directory": "packages/client"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ],
   "exports": {
     "./promise": "./src/promise/index.ts",
-    "./promise/api": "./src/promise/api.ts",
-    "./effect": "./src/effect/index.ts",
-    "./effect/api": "./src/effect/api.ts"
+    "./effect": "./src/effect/index.ts"
   },
   "scripts": {
-    "build": "bun run script/build-package.ts",
     "generate": "bun run script/build.ts",
-    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated src/effect/api",
+    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated",
     "test": "bun test --timeout 5000",
     "typecheck": "tsgo --noEmit"
   },
@@ -42,7 +28,9 @@
   },
   "devDependencies": {
     "@effect/platform-node": "catalog:",
+    "@opencode-ai/core": "workspace:*",
     "@opencode-ai/httpapi-codegen": "workspace:*",
+    "@opencode-ai/server": "workspace:*",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",

packages/client/script/build-package.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-await $`rm -rf dist`
-await $`bun tsc -p tsconfig.build.json`

packages/client/script/build.ts

@@ -32,8 +32,8 @@ await Effect.runPromise(
         fileURLToPath(new URL("../src/effect/generated", import.meta.url)),
       ),
       write(
-        emitEffectShape(effectContract, { module: "../../contract", api: "ClientApi" }),
-        fileURLToPath(new URL("../src/effect/api", import.meta.url)),
+        emitEffectShape(effectContract, { module: "@opencode-ai/protocol/client", api: "ClientApi" }),
+        fileURLToPath(new URL("../../plugin/src/v2/effect/generated", import.meta.url)),
       ),
     ],
     { concurrency: 3, discard: true },

packages/client/script/publish.ts

@@ -1,45 +0,0 @@
-#!/usr/bin/env bun
-
-import { Script } from "@opencode-ai/script"
-import { $ } from "bun"
-import { rm } from "node:fs/promises"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-const originalText = await Bun.file("package.json").text()
-const pkg = JSON.parse(originalText) as {
-  name: string
-  version: string
-  exports: Record<string, string | { import: string; types: string }>
-}
-const tarball = `${pkg.name.replace("@", "").replace("/", "-")}-${pkg.version}.tgz`
-
-if ((await $`npm view ${pkg.name}@${pkg.version} version`.nothrow()).exitCode === 0) {
-  console.log(`already published ${pkg.name}@${pkg.version}`)
-  process.exit(0)
-}
-
-try {
-  await $`bun run typecheck`
-  await $`bun run build`
-  pkg.exports = Object.fromEntries(
-    Object.entries(pkg.exports).map(([key, value]) => {
-      if (typeof value !== "string") return [key, value]
-      return [
-        key,
-        {
-          import: value.replace("./src/", "./dist/").replace(/\.ts$/, ".js"),
-          types: value.replace("./src/", "./dist/").replace(/\.ts$/, ".d.ts"),
-        },
-      ]
-    }),
-  )
-  await Bun.write("package.json", JSON.stringify(pkg, null, 2) + "\n")
-  await rm(tarball, { force: true })
-  await $`bun pm pack`
-  await $`npm publish ${tarball} --tag ${Script.channel} --access public`
-} finally {
-  await Bun.write("package.json", originalText)
-  await rm(tarball, { force: true })
-}

packages/client/src/effect/api.ts

@@ -1,8 +0,0 @@
-import type { ModelApi, ProviderApi } from "./api/api.js"
-
-export type * from "./api/api.js"
-
-export interface CatalogApi<E = never> {
-  readonly provider: ProviderApi<E>
-  readonly model: ModelApi<E>
-}

packages/client/src/effect/generated/client.ts

@@ -82,10 +82,7 @@ const Endpoint4_1 = (raw: RawClient["server.session"]) => (input?: Endpoint4_1In
   )
 
 const Endpoint4_2 = (raw: RawClient["server.session"]) => () =>
-  raw["session.active"]({}).pipe(
-    Effect.mapError(mapClientError),
-    Effect.map((value) => value.data),
-  )
+  raw["session.active"]({}).pipe(Effect.mapError(mapClientError))
 
 type Endpoint4_3Request = Parameters<RawClient["server.session"]["session.get"]>[0]
 type Endpoint4_3Input = { readonly sessionID: Endpoint4_3Request["params"]["sessionID"] }
@@ -211,35 +208,23 @@ const Endpoint4_11 = (raw: RawClient["server.session"]) => (input: Endpoint4_11I
     payload: { text: input["text"], description: input["description"], metadata: input["metadata"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.shell"]>[0]
-type Endpoint4_12Input = {
-  readonly sessionID: Endpoint4_12Request["params"]["sessionID"]
-  readonly id?: Endpoint4_12Request["payload"]["id"]
-  readonly command: Endpoint4_12Request["payload"]["command"]
-}
+type Endpoint4_12Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
+type Endpoint4_12Input = { readonly sessionID: Endpoint4_12Request["params"]["sessionID"] }
 const Endpoint4_12 = (raw: RawClient["server.session"]) => (input: Endpoint4_12Input) =>
-  raw["session.shell"]({
-    params: { sessionID: input["sessionID"] },
-    payload: { id: input["id"], command: input["command"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.compact"]>[0]
-type Endpoint4_13Input = { readonly sessionID: Endpoint4_13Request["params"]["sessionID"] }
-const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
   raw["session.compact"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
-type Endpoint4_14Input = { readonly sessionID: Endpoint4_14Request["params"]["sessionID"] }
-const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
+type Endpoint4_13Request = Parameters<RawClient["server.session"]["session.wait"]>[0]
+type Endpoint4_13Input = { readonly sessionID: Endpoint4_13Request["params"]["sessionID"] }
+const Endpoint4_13 = (raw: RawClient["server.session"]) => (input: Endpoint4_13Input) =>
   raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
-type Endpoint4_15Input = {
-  readonly sessionID: Endpoint4_15Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_15Request["payload"]["messageID"]
-  readonly files?: Endpoint4_15Request["payload"]["files"]
+type Endpoint4_14Request = Parameters<RawClient["server.session"]["session.revert.stage"]>[0]
+type Endpoint4_14Input = {
+  readonly sessionID: Endpoint4_14Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_14Request["payload"]["messageID"]
+  readonly files?: Endpoint4_14Request["payload"]["files"]
 }
-const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
+const Endpoint4_14 = (raw: RawClient["server.session"]) => (input: Endpoint4_14Input) =>
   raw["session.revert.stage"]({
     params: { sessionID: input["sessionID"] },
     payload: { messageID: input["messageID"], files: input["files"] },
@@ -248,61 +233,61 @@ const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15I
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
-type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
-const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
+type Endpoint4_15Request = Parameters<RawClient["server.session"]["session.revert.clear"]>[0]
+type Endpoint4_15Input = { readonly sessionID: Endpoint4_15Request["params"]["sessionID"] }
+const Endpoint4_15 = (raw: RawClient["server.session"]) => (input: Endpoint4_15Input) =>
   raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
-type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
-const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
+type Endpoint4_16Request = Parameters<RawClient["server.session"]["session.revert.commit"]>[0]
+type Endpoint4_16Input = { readonly sessionID: Endpoint4_16Request["params"]["sessionID"] }
+const Endpoint4_16 = (raw: RawClient["server.session"]) => (input: Endpoint4_16Input) =>
   raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.context"]>[0]
-type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
-const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
+type Endpoint4_17Request = Parameters<RawClient["server.session"]["session.context"]>[0]
+type Endpoint4_17Input = { readonly sessionID: Endpoint4_17Request["params"]["sessionID"] }
+const Endpoint4_17 = (raw: RawClient["server.session"]) => (input: Endpoint4_17Input) =>
   raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context.entry.list"]>[0]
-type Endpoint4_19Input = { readonly sessionID: Endpoint4_19Request["params"]["sessionID"] }
-const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
+type Endpoint4_18Request = Parameters<RawClient["server.session"]["session.context.entry.list"]>[0]
+type Endpoint4_18Input = { readonly sessionID: Endpoint4_18Request["params"]["sessionID"] }
+const Endpoint4_18 = (raw: RawClient["server.session"]) => (input: Endpoint4_18Input) =>
   raw["session.context.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
   )
 
-type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context.entry.put"]>[0]
-type Endpoint4_20Input = {
-  readonly sessionID: Endpoint4_20Request["params"]["sessionID"]
-  readonly key: Endpoint4_20Request["params"]["key"]
-  readonly value: Endpoint4_20Request["payload"]["value"]
+type Endpoint4_19Request = Parameters<RawClient["server.session"]["session.context.entry.put"]>[0]
+type Endpoint4_19Input = {
+  readonly sessionID: Endpoint4_19Request["params"]["sessionID"]
+  readonly key: Endpoint4_19Request["params"]["key"]
+  readonly value: Endpoint4_19Request["payload"]["value"]
 }
-const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
+const Endpoint4_19 = (raw: RawClient["server.session"]) => (input: Endpoint4_19Input) =>
   raw["session.context.entry.put"]({
     params: { sessionID: input["sessionID"], key: input["key"] },
     payload: { value: input["value"] },
   }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.context.entry.remove"]>[0]
-type Endpoint4_21Input = {
-  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
-  readonly key: Endpoint4_21Request["params"]["key"]
+type Endpoint4_20Request = Parameters<RawClient["server.session"]["session.context.entry.remove"]>[0]
+type Endpoint4_20Input = {
+  readonly sessionID: Endpoint4_20Request["params"]["sessionID"]
+  readonly key: Endpoint4_20Request["params"]["key"]
 }
-const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
+const Endpoint4_20 = (raw: RawClient["server.session"]) => (input: Endpoint4_20Input) =>
   raw["session.context.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(
     Effect.mapError(mapClientError),
   )
 
-type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.log"]>[0]
-type Endpoint4_22Input = {
-  readonly sessionID: Endpoint4_22Request["params"]["sessionID"]
-  readonly after?: Endpoint4_22Request["query"]["after"]
-  readonly follow?: Endpoint4_22Request["query"]["follow"]
+type Endpoint4_21Request = Parameters<RawClient["server.session"]["session.log"]>[0]
+type Endpoint4_21Input = {
+  readonly sessionID: Endpoint4_21Request["params"]["sessionID"]
+  readonly after?: Endpoint4_21Request["query"]["after"]
+  readonly follow?: Endpoint4_21Request["query"]["follow"]
 }
-const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
+const Endpoint4_21 = (raw: RawClient["server.session"]) => (input: Endpoint4_21Input) =>
   Stream.unwrap(
     raw["session.log"]({
       params: { sessionID: input["sessionID"] },
@@ -313,22 +298,22 @@ const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22I
     ),
   )
 
-type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
-type Endpoint4_23Input = { readonly sessionID: Endpoint4_23Request["params"]["sessionID"] }
-const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
+type Endpoint4_22Request = Parameters<RawClient["server.session"]["session.interrupt"]>[0]
+type Endpoint4_22Input = { readonly sessionID: Endpoint4_22Request["params"]["sessionID"] }
+const Endpoint4_22 = (raw: RawClient["server.session"]) => (input: Endpoint4_22Input) =>
   raw["session.interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.background"]>[0]
-type Endpoint4_24Input = { readonly sessionID: Endpoint4_24Request["params"]["sessionID"] }
-const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
+type Endpoint4_23Request = Parameters<RawClient["server.session"]["session.background"]>[0]
+type Endpoint4_23Input = { readonly sessionID: Endpoint4_23Request["params"]["sessionID"] }
+const Endpoint4_23 = (raw: RawClient["server.session"]) => (input: Endpoint4_23Input) =>
   raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint4_25Request = Parameters<RawClient["server.session"]["session.message"]>[0]
-type Endpoint4_25Input = {
-  readonly sessionID: Endpoint4_25Request["params"]["sessionID"]
-  readonly messageID: Endpoint4_25Request["params"]["messageID"]
+type Endpoint4_24Request = Parameters<RawClient["server.session"]["session.message"]>[0]
+type Endpoint4_24Input = {
+  readonly sessionID: Endpoint4_24Request["params"]["sessionID"]
+  readonly messageID: Endpoint4_24Request["params"]["messageID"]
 }
-const Endpoint4_25 = (raw: RawClient["server.session"]) => (input: Endpoint4_25Input) =>
+const Endpoint4_24 = (raw: RawClient["server.session"]) => (input: Endpoint4_24Input) =>
   raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(
     Effect.mapError(mapClientError),
     Effect.map((value) => value.data),
@@ -347,20 +332,19 @@ const adaptGroup4 = (raw: RawClient["server.session"]) => ({
   command: Endpoint4_9(raw),
   skill: Endpoint4_10(raw),
   synthetic: Endpoint4_11(raw),
-  shell: Endpoint4_12(raw),
-  compact: Endpoint4_13(raw),
-  wait: Endpoint4_14(raw),
-  revertStage: Endpoint4_15(raw),
-  revertClear: Endpoint4_16(raw),
-  revertCommit: Endpoint4_17(raw),
-  context: Endpoint4_18(raw),
-  listContextEntries: Endpoint4_19(raw),
-  putContextEntry: Endpoint4_20(raw),
-  removeContextEntry: Endpoint4_21(raw),
-  log: Endpoint4_22(raw),
-  interrupt: Endpoint4_23(raw),
-  background: Endpoint4_24(raw),
-  message: Endpoint4_25(raw),
+  compact: Endpoint4_12(raw),
+  wait: Endpoint4_13(raw),
+  revertStage: Endpoint4_14(raw),
+  revertClear: Endpoint4_15(raw),
+  revertCommit: Endpoint4_16(raw),
+  context: Endpoint4_17(raw),
+  listContextEntries: Endpoint4_18(raw),
+  putContextEntry: Endpoint4_19(raw),
+  removeContextEntry: Endpoint4_20(raw),
+  log: Endpoint4_21(raw),
+  interrupt: Endpoint4_22(raw),
+  background: Endpoint4_23(raw),
+  message: Endpoint4_24(raw),
 })
 
 type Endpoint5_0Request = Parameters<RawClient["server.message"]["session.messages"]>[0]
@@ -547,29 +531,25 @@ const Endpoint11_1 = (raw: RawClient["server.credential"]) => (input: Endpoint11
 
 const adaptGroup11 = (raw: RawClient["server.credential"]) => ({ update: Endpoint11_0(raw), remove: Endpoint11_1(raw) })
 
-const Endpoint12_0 = (raw: RawClient["server.project"]) => () =>
-  raw["project.list"]({}).pipe(Effect.mapError(mapClientError))
-
-type Endpoint12_1Request = Parameters<RawClient["server.project"]["project.current"]>[0]
-type Endpoint12_1Input = { readonly location?: Endpoint12_1Request["query"]["location"] }
-const Endpoint12_1 = (raw: RawClient["server.project"]) => (input?: Endpoint12_1Input) =>
+type Endpoint12_0Request = Parameters<RawClient["server.project"]["project.current"]>[0]
+type Endpoint12_0Input = { readonly location?: Endpoint12_0Request["query"]["location"] }
+const Endpoint12_0 = (raw: RawClient["server.project"]) => (input?: Endpoint12_0Input) =>
   raw["project.current"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
 
-type Endpoint12_2Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
-type Endpoint12_2Input = {
-  readonly projectID: Endpoint12_2Request["params"]["projectID"]
-  readonly location?: Endpoint12_2Request["query"]["location"]
+type Endpoint12_1Request = Parameters<RawClient["server.project"]["project.directories"]>[0]
+type Endpoint12_1Input = {
+  readonly projectID: Endpoint12_1Request["params"]["projectID"]
+  readonly location?: Endpoint12_1Request["query"]["location"]
 }
-const Endpoint12_2 = (raw: RawClient["server.project"]) => (input: Endpoint12_2Input) =>
+const Endpoint12_1 = (raw: RawClient["server.project"]) => (input: Endpoint12_1Input) =>
   raw["project.directories"]({
     params: { projectID: input["projectID"] },
     query: { location: input["location"] },
   }).pipe(Effect.mapError(mapClientError))
 
 const adaptGroup12 = (raw: RawClient["server.project"]) => ({
-  list: Endpoint12_0(raw),
-  current: Endpoint12_1(raw),
-  directories: Endpoint12_2(raw),
+  current: Endpoint12_0(raw),
+  directories: Endpoint12_1(raw),
 })
 
 type Endpoint13_0Request = Parameters<RawClient["server.form"]["form.request.list"]>[0]
@@ -799,7 +779,15 @@ const Endpoint18_0 = (raw: RawClient["server.event"]) => () =>
     ),
   )
 
-const adaptGroup18 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint18_0(raw) })
+const Endpoint18_1 = (raw: RawClient["server.event"]) => () =>
+  Stream.unwrap(
+    raw["event.changes"]({}).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))),
+    ),
+  )
+
+const adaptGroup18 = (raw: RawClient["server.event"]) => ({ subscribe: Endpoint18_0(raw), changes: Endpoint18_1(raw) })
 
 type Endpoint19_0Request = Parameters<RawClient["server.pty"]["pty.list"]>[0]
 type Endpoint19_0Input = { readonly location?: Endpoint19_0Request["query"]["location"] }
@@ -1042,11 +1030,6 @@ const Endpoint24_1 = (raw: RawClient["server.vcs"]) => (input: Endpoint24_1Input
 
 const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({ status: Endpoint24_0(raw), diff: Endpoint24_1(raw) })
 
-const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
-  raw["debug.location"]({}).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup25 = (raw: RawClient["server.debug"]) => ({ location: Endpoint25_0(raw) })
-
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
   location: adaptGroup1(raw["server.location"]),
@@ -1073,7 +1056,6 @@ const adaptClient = (raw: RawClient) => ({
   reference: adaptGroup22(raw["server.reference"]),
   projectCopy: adaptGroup23(raw["server.projectCopy"]),
   vcs: adaptGroup24(raw["server.vcs"]),
-  debug: adaptGroup25(raw["server.debug"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

packages/client/src/effect/index.ts

@@ -1,23 +1,8 @@
 // TODO: Keep additional network capabilities inside Schema and Protocol as the client grows; /effect must never import
 // Core or Server. Preserve these datatype exports so internal model reorganizations do not require caller migrations.
-import type { Effect } from "effect"
-
 export * from "./generated/index"
-export type {
-  AgentApi,
-  AppApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  IntegrationApi,
-  ModelApi,
-  PluginApi,
-  ProviderApi,
-  ReferenceApi,
-  SessionApi,
-  SkillApi,
-} from "./api.js"
 export { Service } from "./service.js"
+export type { Transport, ServiceOptions } from "./service.js"
 export { Agent } from "@opencode-ai/schema/agent"
 export { Command } from "@opencode-ai/schema/command"
 export { Credential } from "@opencode-ai/schema/credential"
@@ -43,4 +28,3 @@ export { SessionMessage } from "@opencode-ai/schema/session-message"
 export { Skill } from "@opencode-ai/schema/skill"
 export { Prompt } from "@opencode-ai/schema/prompt"
 export type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
-export type OpenCodeClient = Effect.Success<ReturnType<typeof import("./generated/client").make>>

packages/client/src/effect/service.ts

@@ -16,7 +16,7 @@ export type Transport = {
   readonly headers?: RequestInit["headers"]
 }
 
-export type Options = {
+export type ServiceOptions = {
   // Absolute path to the service registration file. Defaults to
   // opencode/service.json in the XDG state directory.
   readonly file?: string
@@ -30,58 +30,44 @@ export type Options = {
 
 // Read-only lookup: registration file plus health check and version gate.
 // Never spawns; escalation to start() is the caller's policy.
-export const discover = Effect.fn("service.discover")(function* (options: Options = {}) {
-  return (yield* discoverLocal(options))?.transport
-})
-
-const discoverLocal = Effect.fnUntraced(function* (options: Options) {
-  const info = yield* read(options.file)
-  if (info === undefined) return undefined
-  if (options.version !== undefined && info.version !== options.version) return undefined
-  return yield* probe(info, options.version)
+export const discover = Effect.fn("service.discover")(function* (options: ServiceOptions = {}) {
+  const registration = yield* read(options.file)
+  if (registration === undefined) return undefined
+  if (options.version !== undefined && registration.version !== options.version) return undefined
+  const found = yield* probe(registration)
+  return found?.transport
 })
 
 // Idempotent ensure-running: reuses a healthy compatible server, replaces a
 // version-mismatched one, and otherwise spawns the service command detached.
-export const start = Effect.fn("service.start")(function* (options: Options = {}) {
+export const start = Effect.fn("service.start")(function* (options: ServiceOptions = {}) {
   const compatible = yield* discover(options)
   if (compatible !== undefined) return compatible
   const mismatched = yield* find(options)
-  if (mismatched !== undefined) yield* kill(mismatched.info, options).pipe(Effect.ignore)
+  if (mismatched !== undefined) yield* kill(mismatched.registration, options).pipe(Effect.ignore)
 
   const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
   if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
-  const child = yield* Effect.try({
+  yield* Effect.try({
     try: () => {
-      const child = spawn(command, args, { detached: true, stdio: "ignore" })
-      child.unref()
-      return child
+      spawn(command, args, { detached: true, stdio: "ignore" }).unref()
     },
     catch: (cause) => new Error("Failed to start server", { cause }),
   })
 
-  return yield* discoverLocal(options).pipe(
+  return yield* discover(options).pipe(
     Effect.flatMap((found) =>
       found === undefined ? Effect.fail(new Error("Server is not ready")) : Effect.succeed(found),
     ),
     Effect.retry(poll),
-    Effect.tap((found) =>
-      found.info.pid === child.pid
-        ? Effect.void
-        : Effect.sync(() => {
-            child.kill("SIGTERM")
-          }),
-    ),
-    Effect.map((found) => found.transport),
-    Effect.tapError(() => Effect.try({ try: () => child.kill("SIGTERM"), catch: () => undefined }).pipe(Effect.ignore)),
     Effect.mapError(() => new Error("Failed to start server")),
   )
 })
 
-export const stop = Effect.fn("service.stop")(function* (options: Options = {}) {
+export const stop = Effect.fn("service.stop")(function* (options: ServiceOptions = {}) {
   const fs = yield* FileSystem.FileSystem
   const existing = yield* find(options)
-  if (existing !== undefined) yield* kill(existing.info, options)
+  if (existing !== undefined) yield* kill(existing.registration, options)
   yield* fs.remove(options.file ?? fallback()).pipe(Effect.ignore)
 })
 
@@ -94,22 +80,18 @@ function auth(password: string): RequestInit["headers"] {
   return { authorization: "Basic " + btoa("opencode:" + password) }
 }
 
-export const Info = Schema.Struct({
+const Registration = Schema.Struct({
   id: Schema.optional(Schema.String),
   version: Schema.optional(Schema.String),
   url: Schema.String,
   pid: Schema.Int.check(Schema.isGreaterThan(0)),
   password: Schema.optional(Schema.String),
 })
-export type Info = typeof Info.Type
+type Registration = typeof Registration.Type
 
-const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Info))
-const decodeHealth = Schema.decodeUnknownOption(
-  Schema.Struct({ healthy: Schema.Literal(true), version: Schema.String, pid: Schema.Int }),
-)
-const decodeLegacyHealth = Schema.decodeUnknownOption(Schema.Struct({ healthy: Schema.Literal(true) }))
+const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
 
-// A missing or corrupt file means no valid info; callers treat both
+// A missing or corrupt file means no valid registration; callers treat both
 // the same (the registering server self-evicts, clients rediscover).
 const read = Effect.fnUntraced(function* (file?: string) {
   const fs = yield* FileSystem.FileSystem
@@ -119,42 +101,31 @@ const read = Effect.fnUntraced(function* (file?: string) {
 })
 
 type LocalService = {
-  readonly info: Info
+  readonly registration: Registration
   readonly transport: Transport
 }
 
-const probe = Effect.fnUntraced(function* (info: Info, version?: string, allowLegacy = false) {
-  const headers = info.password === undefined ? undefined : auth(info.password)
-  const response = yield* Effect.tryPromise(() =>
-    fetch(new URL("/api/health", info.url), {
+const probe = Effect.fnUntraced(function* (registration: Registration) {
+  const headers = registration.password === undefined ? undefined : auth(registration.password)
+  const healthy = yield* Effect.tryPromise(() =>
+    fetch(new URL("/api/health", registration.url), {
       headers,
       signal: AbortSignal.timeout(2_000),
     }),
-  ).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-  if (response === undefined || !response.ok) return undefined
-  const body = yield* Effect.tryPromise(() => response.json()).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-  const health = decodeHealth(body)
-  if (Option.isSome(health)) {
-    if (health.value.pid !== info.pid) return undefined
-    if (info.version !== undefined && health.value.version !== info.version) return undefined
-    if (version !== undefined && health.value.version !== version) return undefined
-    return { info, transport: { url: info.url, headers } } satisfies LocalService
-  }
-  if (
-    !allowLegacy ||
-    Option.isNone(decodeLegacyHealth(body)) ||
-    (typeof body === "object" && body !== null && ("version" in body || "pid" in body))
+  ).pipe(
+    Effect.map((response) => response.ok),
+    Effect.orElseSucceed(() => false),
   )
-    return undefined
-  return { info, transport: { url: info.url, headers } } satisfies LocalService
+  if (!healthy) return undefined
+  return { registration, transport: { url: registration.url, headers } } satisfies LocalService
 })
 
 // Health-checked lookup without the version gate: lifecycle operations must be
 // able to see (and replace or stop) a server from a different version.
-const find = Effect.fnUntraced(function* (options: Options) {
-  const info = yield* read(options.file)
-  if (info === undefined) return undefined
-  return yield* probe(info, undefined, true)
+const find = Effect.fnUntraced(function* (options: ServiceOptions) {
+  const registration = yield* read(options.file)
+  if (registration === undefined) return undefined
+  return yield* probe(registration)
 })
 
 // 50ms cadence bounded at ~5s, shared by stop escalation and start readiness.
@@ -171,22 +142,22 @@ const stopped = Effect.fnUntraced(function* (pid: number) {
   return yield* Effect.fail(new Error(`Server process ${pid} is still running`))
 })
 
-function same(left: Info, right: Info) {
+function same(left: Registration, right: Registration) {
   return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
 }
 
-const kill = Effect.fnUntraced(function* (info: Info, options: Options) {
+const kill = Effect.fnUntraced(function* (info: Registration, options: ServiceOptions) {
   // A stale registration may point at a PID that has since been reused by
   // another process. Only signal the PID after authenticating the server.
   const current = yield* find(options)
-  if (current === undefined || !same(current.info, info)) return
+  if (current === undefined || !same(current.registration, info)) return
 
   yield* signal(info.pid, "SIGTERM")
   const done = yield* stopped(info.pid).pipe(Effect.retry(poll), Effect.option)
   if (Option.isSome(done)) return
 
   const latest = yield* find(options)
-  if (latest === undefined || !same(latest.info, info)) return
+  if (latest === undefined || !same(latest.registration, info)) return
   yield* signal(info.pid, "SIGKILL")
   yield* stopped(info.pid).pipe(Effect.retry(poll))
 })

packages/client/src/promise/api.ts

@@ -1,41 +0,0 @@
-import type {
-  AgentApi as EffectAgentApi,
-  CommandApi as EffectCommandApi,
-  EventApi as EffectEventApi,
-  IntegrationApi as EffectIntegrationApi,
-  ModelApi as EffectModelApi,
-  PluginApi as EffectPluginApi,
-  ProviderApi as EffectProviderApi,
-  ReferenceApi as EffectReferenceApi,
-  SessionApi as EffectSessionApi,
-  SkillApi as EffectSkillApi,
-} from "../effect/api/api.js"
-import type { Effect, Stream } from "effect"
-
-type PromisifyOperation<Operation> = Operation extends (
-  ...args: infer Args
-) => Effect.Effect<infer Success, unknown, unknown>
-  ? (...args: Args) => Promise<Success>
-  : Operation extends (...args: infer Args) => Stream.Stream<infer Success, unknown, unknown>
-    ? (...args: Args) => AsyncIterable<Success>
-    : Operation
-
-type PromisifyApi<Api> = {
-  readonly [Name in keyof Api]: PromisifyOperation<Api[Name]>
-}
-
-export type AgentApi = PromisifyApi<EffectAgentApi<unknown>>
-export type CommandApi = PromisifyApi<EffectCommandApi<unknown>>
-export type EventApi = PromisifyApi<EffectEventApi<unknown>>
-export type IntegrationApi = PromisifyApi<EffectIntegrationApi<unknown>>
-export type ModelApi = PromisifyApi<EffectModelApi<unknown>>
-export type PluginApi = PromisifyApi<EffectPluginApi<unknown>>
-export type ProviderApi = PromisifyApi<EffectProviderApi<unknown>>
-export type ReferenceApi = PromisifyApi<EffectReferenceApi<unknown>>
-export type SessionApi = PromisifyApi<EffectSessionApi<unknown>>
-export type SkillApi = PromisifyApi<EffectSkillApi<unknown>>
-
-export interface CatalogApi {
-  readonly provider: ProviderApi
-  readonly model: ModelApi
-}

packages/client/src/promise/generated/client.ts

@@ -29,8 +29,6 @@ import type {
   SessionSkillOutput,
   SessionSyntheticInput,
   SessionSyntheticOutput,
-  SessionShellInput,
-  SessionShellOutput,
   SessionCompactInput,
   SessionCompactOutput,
   SessionWaitInput,
@@ -89,7 +87,6 @@ import type {
   CredentialUpdateOutput,
   CredentialRemoveInput,
   CredentialRemoveOutput,
-  ProjectListOutput,
   ProjectCurrentInput,
   ProjectCurrentOutput,
   ProjectDirectoriesInput,
@@ -133,6 +130,7 @@ import type {
   SkillListInput,
   SkillListOutput,
   EventSubscribeOutput,
+  EventChangesOutput,
   PtyListInput,
   PtyListOutput,
   PtyCreateInput,
@@ -173,7 +171,6 @@ import type {
   VcsStatusOutput,
   VcsDiffInput,
   VcsDiffOutput,
-  DebugLocationOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -401,7 +398,7 @@ export function make(options: ClientOptions) {
           requestOptions,
         ).then((value) => value.data),
       active: (requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionActiveOutput }>(
+        request<SessionActiveOutput>(
           {
             method: "GET",
             path: `/api/session/active`,
@@ -410,7 +407,7 @@ export function make(options: ClientOptions) {
             empty: false,
           },
           requestOptions,
-        ).then((value) => value.data),
+        ),
       get: (input: SessionGetInput, requestOptions?: RequestOptions) =>
         request<{ readonly data: SessionGetOutput }>(
           {
@@ -528,18 +525,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      shell: (input: SessionShellInput, requestOptions?: RequestOptions) =>
-        request<SessionShellOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
-            body: { id: input["id"], command: input["command"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
       compact: (input: SessionCompactInput, requestOptions?: RequestOptions) =>
         request<SessionCompactOutput>(
           {
@@ -645,7 +630,7 @@ export function make(options: ClientOptions) {
         sse<SessionLogOutput>(
           {
             method: "GET",
-            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/log`,
             query: { after: input["after"], follow: input["follow"] },
             successStatus: 200,
             declaredStatuses: [404, 400, 401],
@@ -899,11 +884,6 @@ export function make(options: ClientOptions) {
         ),
     },
     project: {
-      list: (requestOptions?: RequestOptions) =>
-        request<ProjectListOutput>(
-          { method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
-          requestOptions,
-        ),
       current: (input?: ProjectCurrentInput, requestOptions?: RequestOptions) =>
         request<ProjectCurrentOutput>(
           {
@@ -1182,6 +1162,11 @@ export function make(options: ClientOptions) {
           { method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
           requestOptions,
         ),
+      changes: (requestOptions?: RequestOptions): AsyncIterable<EventChangesOutput> =>
+        sse<EventChangesOutput>(
+          { method: "GET", path: `/api/event/changes`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
+          requestOptions,
+        ),
     },
     pty: {
       list: (input?: PtyListInput, requestOptions?: RequestOptions) =>
@@ -1449,19 +1434,6 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
-    debug: {
-      location: (requestOptions?: RequestOptions) =>
-        request<DebugLocationOutput>(
-          {
-            method: "GET",
-            path: `/api/debug/location`,
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
   }
 }
 

packages/client/src/promise/index.ts

@@ -1,16 +1,4 @@
 export * from "./generated/index"
-export type {
-  AgentApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  IntegrationApi,
-  ModelApi,
-  PluginApi,
-  ProviderApi,
-  ReferenceApi,
-  SessionApi,
-  SkillApi,
-} from "./api.js"
+export type { Transport } from "../effect/service.js"
 export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types"
 export type OpenCodeClient = ReturnType<typeof import("./generated/client").make>

packages/client/test/api.types.ts

@@ -1,10 +0,0 @@
-import { Effect } from "effect"
-import { OpenCode as EffectOpenCode, type AppApi as EffectApi } from "../src/effect"
-
-type EffectClient = Effect.Success<ReturnType<typeof EffectOpenCode.make>>
-
-declare const effectClient: EffectClient
-
-const effectApi: EffectApi<unknown> = effectClient
-
-void effectApi

packages/client/test/effect.test.ts

@@ -1,17 +1,7 @@
 import { expect, test } from "bun:test"
 import { DateTime, Effect, Stream } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import {
-  AbsolutePath,
-  Agent,
-  Event,
-  Location,
-  Model,
-  OpenCode,
-  Prompt,
-  Session,
-  SessionMessage,
-} from "../src/effect/index"
+import { AbsolutePath, Agent, Event, Location, Model, OpenCode, Prompt, Session, SessionMessage } from "../src/effect/index"
 
 const synced = { type: "log.synced" as const, aggregateID: "ses_test", seq: Event.Seq.make(1) }
 
@@ -33,7 +23,7 @@ test("event.subscribe exposes and decodes the native Effect event stream", async
       HttpClientResponse.fromWeb(
         request,
         new Response(
-          `data: ${JSON.stringify({ id: "evt_connected", created: 0, type: "server.connected", data: {} })}\n\n` +
+          `data: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
             `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
           { headers: { "content-type": "text/event-stream" } },
         ),
@@ -45,10 +35,10 @@ test("event.subscribe exposes and decodes the native Effect event stream", async
     return yield* client.event.subscribe().pipe(Stream.runCollect)
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
-  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.model.selected"])
+  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.next.model.switched"])
   const durable = events[1]
-  if (durable?.type !== "session.model.selected") throw new Error("Expected model event")
-  expect(DateTime.toEpochMillis(durable.created)).toBe(1_717_171_717_000)
+  if (durable?.type !== "session.next.model.switched") throw new Error("Expected model event")
+  expect(DateTime.toEpochMillis(durable.data.timestamp)).toBe(1_717_171_717_000)
   expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
 })
 
@@ -99,7 +89,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
       return Effect.succeed(
         HttpClientResponse.fromWeb(
           request,
-          Response.json({ data: { ses_test: { type: "running" } } }),
+          Response.json({ data: { ses_test: { type: "running" } }, watermarks: { ses_test: 3 } }),
         ),
       )
     }
@@ -112,7 +102,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     return Effect.succeed(
       HttpClientResponse.fromWeb(
         request,
-        Response.json({ data: [session.data], cursor: { next: "next" } }),
+        Response.json({ data: [session.data], watermarks: { ses_test: 3 }, cursor: { next: "next" } }),
       ),
     )
   })
@@ -148,7 +138,8 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
   expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
-  expect(result.active).toEqual({ ses_test: { type: "running" } })
+  expect(result.active).toEqual({ data: { ses_test: { type: "running" } }, watermarks: { ses_test: 3 } })
+  expect(result.page.watermarks).toEqual({ ses_test: 3 })
   expect(Object.getPrototypeOf(result.page.data[0])).toBe(Object.prototype)
   expect(Object.getPrototypeOf(result.created)).toBe(Object.prototype)
   expect(result.created.id).toBe("ses_test")
@@ -158,8 +149,8 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(result.context).toEqual([])
   expect(logQueries[0]).toEqual({ after: "0" })
   const logged = Array.from(result.log)
-  expect(logged.map((item) => item.type)).toEqual(["session.model.selected", "log.synced"])
-  expect(logged[0]?.type === "session.model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
+  expect(logged.map((item) => item.type)).toEqual(["session.next.model.switched", "log.synced"])
+  expect(logged[0]?.type === "session.next.model.switched" && DateTime.toEpochMillis(logged[0].data.timestamp)).toBe(
     1_717_171_717_000,
   )
   expect(logged.at(-1)).toEqual(synced)
@@ -226,11 +217,12 @@ const modelSwitchedMessage = {
 
 const modelSwitchedEvent = {
   id: "evt_model",
-  created: 1_717_171_717_000,
-  type: "session.model.selected",
+  type: "session.next.model.switched",
   durable: { aggregateID: "ses_test", seq: 1, version: 1 },
   data: {
+    timestamp: 1_717_171_717_000,
     sessionID: "ses_test",
+    messageID: "msg_model",
     model: { id: "claude", providerID: "anthropic" },
   },
 }

packages/client/test/promise.test.ts

@@ -30,9 +30,7 @@ test("exposes every standard HTTP API group", () => {
     "reference",
     "projectCopy",
     "vcs",
-    "debug",
   ])
-  expect(Object.keys(client.debug)).toEqual(["location"])
   expect(Object.keys(client.message)).toEqual(["list"])
   expect(Object.keys(client.integration)).toEqual([
     "list",
@@ -47,7 +45,7 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.vcs)).toEqual(["status", "diff"])
   expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
   expect(Object.keys(client.shell)).toEqual(["list", "create", "get", "output", "remove"])
-  expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
+  expect(Object.keys(client.project)).toEqual(["current", "directories"])
 })
 
 test("file.read returns binary content from the public HTTP contract", async () => {
@@ -153,7 +151,7 @@ test("event.subscribe exposes the Promise event stream wire projection", async (
     baseUrl: "http://localhost:3000",
     fetch: async () =>
       new Response(
-        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", created: 0, type: "server.connected", data: {} })}\n\n` +
+        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
           `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
         { headers: { "content-type": "text/event-stream" } },
       ),
@@ -161,8 +159,8 @@ test("event.subscribe exposes the Promise event stream wire projection", async (
   const events = []
   for await (const event of client.event.subscribe()) events.push(event)
 
-  expect(events).toEqual([{ id: "evt_connected", created: 0, type: "server.connected", data: {} }, modelSwitchedEvent])
-  expect(events[1]?.type === "session.model.selected" && events[1].created).toBe(1_717_171_717_000)
+  expect(events).toEqual([{ id: "evt_connected", type: "server.connected", data: {} }, modelSwitchedEvent])
+  expect(events[1]?.type === "session.next.model.switched" && events[1].data.timestamp).toBe(1_717_171_717_000)
 })
 
 test("event.subscribe terminates on malformed Promise SSE data", async () => {
@@ -198,7 +196,7 @@ test("session methods use the public HTTP contract", async () => {
       if (url.includes("/context")) return Response.json({ data: [] })
       if (url.includes("/message/")) return Response.json({ data: modelSwitchedMessage })
       if (url.endsWith("/api/session/active"))
-        return Response.json({ data: { ses_test: { type: "running" } } })
+        return Response.json({ data: { ses_test: { type: "running" } }, watermarks: { ses_test: 3 } })
       if (init?.method === "POST" && url.endsWith("/api/session")) return Response.json(session)
       if (init?.method === "POST") return new Response(null, { status: 204 })
       return Response.json({ data: [session.data], cursor: { next: "next" } })
@@ -227,7 +225,7 @@ test("session methods use the public HTTP contract", async () => {
   const message = await client.session.message({ sessionID: "ses_test", messageID: "msg_model" })
 
   expect(page.cursor.next).toBe("next")
-  expect(active).toEqual({ ses_test: { type: "running" } })
+  expect(active).toEqual({ data: { ses_test: { type: "running" } }, watermarks: { ses_test: 3 } })
   expect(created.id).toBe("ses_test")
   expect(admitted.id).toBe("msg_test")
   expect(context).toEqual([])
@@ -243,7 +241,7 @@ test("session methods use the public HTTP contract", async () => {
     ["POST", "http://localhost:3000/api/session/ses_test/compact"],
     ["POST", "http://localhost:3000/api/session/ses_test/wait"],
     ["GET", "http://localhost:3000/api/session/ses_test/context"],
-    ["GET", "http://localhost:3000/api/experimental/session/ses_test/log?after=0"],
+    ["GET", "http://localhost:3000/api/session/ses_test/log?after=0"],
     ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
     ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
   ])
@@ -330,11 +328,12 @@ const synced = { type: "log.synced", aggregateID: "ses_test", seq: 1 }
 
 const modelSwitchedEvent = {
   id: "evt_model",
-  created: 1_717_171_717_000,
-  type: "session.model.selected",
+  type: "session.next.model.switched",
   durable: { aggregateID: "ses_test", seq: 1, version: 1 },
   data: {
+    timestamp: 1_717_171_717_000,
     sessionID: "ses_test",
+    messageID: "msg_model",
     model: { id: "claude", providerID: "anthropic" },
   },
 }

packages/client/tsconfig.build.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "noEmit": false,
-    "declaration": true
-  },
-  "include": ["src"]
-}

packages/client/tsconfig.json

@@ -3,8 +3,6 @@
   "extends": "@tsconfig/bun/tsconfig.json",
   "compilerOptions": {
     "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "allowImportingTsExtensions": false,
-    "allowJs": false,
     "noUncheckedIndexedAccess": false
   },
   "include": ["src"]

packages/codemode/AGENTS.md

@@ -5,14 +5,6 @@
 - Keep Code Mode unaware of host session, channel, and conversation models. The hosting application supplies trusted execution scope around it.
 - Tool schemas are the model-facing Interface. Keep arguments minimal and natural to the operation; never add unrelated IDs as ambient capability tokens.
 
-## OpenAPI
-
-- Generate an operation only when its transport semantics are supported; otherwise return a precise `skipped` reason.
-- Never guess parameter serialization or malformed security semantics. Unsupported serialization is skipped and malformed security fails closed.
-- Render unresolved schema constructs as `unknown`, never as invented TypeScript names.
-- Keep network reads bounded and map expected encoding, transport, and decoding failures to model-safe `ToolError` values.
-- Test supported behavior directly; do not reproduce adapter algorithms in tests.
-
 ## Future Design Notes
 
 - If a captured user-visible output channel returns (an earlier `output.text`/`output.file`/`output.image` API was removed from v1), keep `output` as its name, distinct from the program return value: `return` stays the structured result for the model, while `output.*` describes artifacts the host may render into a conversation or UI after execution. Keep this host-neutral and let applications decide how captured output is delivered. In v1, hosts collect media host-side (outside the sandbox) instead.

packages/codemode/README.md

@@ -4,7 +4,7 @@ Effect-native confined code execution over explicit, schema-described tools.
 
 CodeMode lets a model write a small JavaScript program that can call only the tools supplied by the host. The program can sequence calls, transform plain data, branch, loop, and run independent calls in parallel without receiving ambient filesystem, process, network, module, or application authority.
 
-The package is currently private to this workspace. Its API is designed around one-shot and reusable execution:
+The package is currently private to this workspace. Its API is designed around three uses:
 
 ```ts
 // One execution
@@ -13,6 +13,9 @@ yield * CodeMode.execute({ tools, code })
 // A reusable runtime
 const runtime = CodeMode.make({ tools, limits })
 yield * runtime.execute(code)
+
+// One agent-facing code tool
+const codeTool = runtime.agentTool()
 ```
 
 ## Install
@@ -60,7 +63,7 @@ const result =
 `)
 ```
 
-`result` is always a `CodeMode.Result`. Program, validation, limit, and tool failures are returned as diagnostics rather than failing the Effect. Host interruption remains interruption.
+`result` is always an `ExecuteResult`. Program, validation, limit, and tool failures are returned as diagnostics rather than failing the Effect. Host interruption remains interruption.
 
 Successful result values are JSON-safe data. A program that returns `undefined`, including by reaching the end without `return`, produces `null`; nested `undefined` values are normalized to `null` as well.
 
@@ -83,8 +86,6 @@ const tool = Tool.make({
 
 The description and schemas are part of the model-visible tool contract. Keep descriptions concrete and put authorization in `run` or in the service it calls.
 
-Public tool types are grouped under the same namespace: `Tool.Definition`, `Tool.Options`, `Tool.SchemaType`, and `Tool.JsonSchema`.
-
 ### `CodeMode.execute`
 
 Use `CodeMode.execute` for a single execution:
@@ -115,32 +116,31 @@ const runtime = CodeMode.make({
 
 runtime.catalog() // structured tool descriptions
 runtime.instructions() // model-facing syntax and tool guide
-runtime.execute(source) // CodeMode.Result
+runtime.execute(source) // ExecuteResult
+runtime.agentTool() // { name, description, input, output, execute }
 ```
 
-`CodeMode.Input`, `CodeMode.Result`, `CodeMode.Success`, `CodeMode.Failure`, `CodeMode.Diagnostic`, and `CodeMode.DiagnosticKind` are both Effect schemas and their inferred TypeScript types. Hosts can combine `CodeMode.Input` and `CodeMode.Result` with `runtime.instructions()` and `runtime.execute()` when constructing a framework-specific agent tool.
-
-All other CodeMode types use the same namespace: `CodeMode.Options`, `CodeMode.ExecuteOptions`, `CodeMode.Runtime`, `CodeMode.ExecutionLimits`, `CodeMode.DiscoveryOptions`, `CodeMode.DataValue`, `CodeMode.ToolDescription`, and the `CodeMode.ToolCall*` observation types.
+`catalog`, `instructions`, and `agentTool` are projections of the same configured tool tree. `agentTool().description` is exactly `instructions()`.
 
 ### Results
 
 ```ts
-type Result = Success | Failure
+type ExecuteResult = ExecuteSuccess | ExecuteFailure
 
-interface Success {
+interface ExecuteSuccess {
   readonly ok: true
-  readonly value: CodeMode.DataValue
+  readonly value: Schema.Json
   readonly logs?: ReadonlyArray<string>
   readonly truncated?: boolean
-  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
+  readonly toolCalls: ReadonlyArray<ToolCall>
 }
 
-interface Failure {
+interface ExecuteFailure {
   readonly ok: false
-  readonly error: CodeMode.Diagnostic
+  readonly error: Diagnostic
   readonly logs?: ReadonlyArray<string>
   readonly truncated?: boolean
-  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
+  readonly toolCalls: ReadonlyArray<ToolCall>
 }
 ```
 
@@ -152,41 +152,16 @@ interface Failure {
 
 `onToolCallEnd` receives `{ index, name, input, durationMs, outcome, message? }` when an admitted call settles. `outcome` is `"success"` or `"failure"`; `message` is the model-safe failure message and is present only on failure. Interrupted calls (for example when the execution timeout fires) do not produce an end event. Both hooks are Effect-returning and must not fail.
 
-### OpenAPI tools
-
-`OpenAPI.fromSpec` turns an OpenAPI 3.x document into a tool subtree - one tool per operation. Dotted `operationId` values form namespaces such as `v2.session.get`. Missing IDs receive a flat method/path fallback such as `getUsersById`; names are sanitized and deduplicated. The host places the subtree under a key in its `tools` tree; that key is the model-visible namespace.
-
-```ts
-import { CodeMode, OpenAPI } from "@opencode-ai/codemode"
-import { Effect } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-
-const api = OpenAPI.fromSpec({
-  spec: await Bun.file("openapi.json").json(), // parsed document (no YAML)
-  auth: {
-    resolve: ({ name, scopes, operation }) =>
-      name === "BearerAuth" ? Effect.succeed({ type: "bearer", token }) : Effect.succeed(undefined),
-  },
-})
-
-const runtime = CodeMode.make({ tools: { opencode: api.tools } })
-const result = await Effect.runPromise(runtime.execute(code).pipe(Effect.provide(FetchHttpClient.layer)))
-```
-
-`fromSpec` is synchronous and returns `{ tools, skipped }`. The initial adapter supports query `form`/`deepObject`, path/header `simple`, JSON request bodies, JSON responses, and text responses; unsupported parameter encodings, non-JSON request bodies, binary responses, and streaming operations land in `skipped` instead of producing broken tools. Operation and path servers take precedence over document servers unless `baseUrl` explicitly overrides all of them. Tool inputs flatten path, query, header, and closed object-body fields into one model-facing object while retaining their HTTP locations internally. Cross-location name collisions receive a location prefix such as `path_id` and `query_id`; composed, nullable, dictionary, conditionally-required, and non-object JSON bodies remain under `body`. Auth is never model-visible. Responses are limited to 50 MiB, and non-2xx responses become safe tool failures carrying the status and a size-capped body summary. Deferred capabilities are tracked in `src/openapi/TODO.md`.
-
-Supported bearer, basic, header, and query authentication follows OpenAPI `security` semantics and is resolved host-side via `auth.resolve` - credential storage, OAuth flows, and token refresh never enter the compiler. Cookie authentication alternatives are discarded; an operation is skipped when it has no supported alternative. See the option docstrings in `src/openapi/types.ts` for the full semantics. Generated tools require `HttpClient.HttpClient` (from `effect/unstable/http`) in the Effect environment - provide `FetchHttpClient.layer` or a custom/test client layer at execution. The supplied client owns redirect policy; credentialed hosts should reject redirects or strip credentials when the origin changes.
-
 ## Discovery
 
-The agent-tool instructions use a budgeted catalog. Every tool namespace is always listed with its tool count regardless of budget, and as many complete, JSDoc-annotated tool signatures (each with a one-line description) as fit an estimated-token budget are inlined. Schema field descriptions and tags are part of each signature's measured cost. Selection is round-robin across namespaces for fairness: in each round (namespaces alphabetical), every namespace still holding un-inlined tools attempts to place its next-cheapest signature against the shared budget, and a namespace whose next signature does not fit drops out while the others keep going - so every namespace gets some representation before any namespace gets everything. The instructions state exactly how comprehensive the list is, both overall (`COMPLETE list` vs `PARTIAL - N of M shown`) and per namespace (`(3 tools)`, `(3 tools, 1 shown)`, `(3 tools, none shown)`).
+The agent-tool instructions use a budgeted catalog. Every tool namespace is always listed with its tool count regardless of budget, and as many complete tool signatures (each with a one-line description) as fit an estimated-token budget are inlined. Selection is round-robin across namespaces for fairness: in each round (namespaces alphabetical), every namespace still holding un-inlined tools attempts to place its next-cheapest signature line against the shared budget, and a namespace whose next line does not fit drops out while the others keep going - so every namespace gets some representation before any namespace gets everything. The instructions state exactly how comprehensive the list is, both overall (`COMPLETE list` vs `PARTIAL - N of M shown`) and per namespace (`(3 tools)`, `(3 tools, 1 shown)`, `(3 tools, none shown)`).
 
-The catalog-entry budget defaults to 2,000 estimated tokens (characters / 4, the same heuristic OpenCode uses). It applies only to full tool entries shown in the catalog; fixed instructions and namespace summaries are not counted. Override it when constructing a runtime:
+The default budget is 2,000 estimated tokens (characters / 4, the same heuristic OpenCode uses). Override it when constructing a runtime:
 
 ```ts
 const runtime = CodeMode.make({
   tools,
-  discovery: { catalogBudget: 6_000 },
+  discovery: { maxInlineCatalogTokens: 6_000 },
 })
 ```
 
@@ -199,37 +174,30 @@ const matches = await tools.$codemode.search({
   query: "order status",
   namespace: "orders", // optional: scope to one top-level namespace
   limit: 10,
-  offset: 0,
 })
 ```
 
-`search` performs deterministic, additive field-weighted matching. The query is tokenized (camelCase boundaries split; every non-alphanumeric character is a separator; empties and `*` are dropped), and each term scores every tool: exact path or path-segment match (20), path substring (8), description substring (4), and searchable-text substring (2). Each term also carries naive singular variants (trailing `s`/`es` stripped), and a field check passes when the term or any variant matches - so a plural query term (`issues`) still finds a tool whose text only says `issue`, without changing the weights. The searchable text also includes the input schema's property names and their description strings, so a query naming a parameter finds its tool, and substring matching means partial words match. Scores sum across terms; matches are sorted by score (ties broken alphabetically by path), then sliced from the zero-based `offset` (default 0) to the configured `limit` (default 10). `remaining` counts matches after the current page. `next` is `{ offset }` when another page exists and `null` on the final page; spread it into the original request to preserve its query, namespace, and limit.
+`search` performs deterministic, additive field-weighted matching. The query is tokenized (camelCase boundaries split; every non-alphanumeric character is a separator; empties and `*` are dropped), and each term scores every tool: exact path or path-segment match (20), path substring (8), description substring (4), and searchable-text substring (2). Each term also carries naive singular variants (trailing `s`/`es` stripped), and a field check passes when the term or any variant matches - so a plural query term (`issues`) still finds a tool whose text only says `issue`, without changing the weights. The searchable text also includes the input schema's property names and their description strings, so a query naming a parameter finds its tool, and substring matching means partial words match. Scores sum across terms; matches are sorted by score (ties broken alphabetically by path) and capped at `limit` results (default 10).
 
-```ts
-const request = { query: "order status", namespace: "orders", limit: 10 }
-const page = await tools.$codemode.search(request)
-const nextPage = page.next ? await tools.$codemode.search({ ...request, ...page.next }) : undefined
-```
-
-Each result contains the path, description, and the same generated TypeScript signature used by the inline catalog, so no second lookup is needed. Signatures use the JSDoc-annotated multiline form: each described input/output field carries its schema `description` as a `/** ... */` comment, and constraints TypeScript cannot express ride along as tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`).
+Each result contains the path, description, and generated TypeScript signature, so no second lookup is needed. The result signature is the pretty, JSDoc-annotated multiline form: each described input/output field carries its schema `description` as a `/** ... */` comment, and constraints TypeScript cannot express ride along as tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`). The inline catalog in the instructions keeps the compact single-line form.
 
 ```ts
 tools.github.list_issues(input: {
   /** Repository owner */
-  owner: string,
+  owner: string
   /** Cursor from the previous response's pageInfo */
-  after?: string,
+  after?: string
   /**
    * Results per page
    * @default 30
    */
-  perPage?: number,
+  perPage?: number
 }): Promise<unknown>
 ```
 
 Result paths are rendered as JavaScript expressions rooted at `tools` (`tools.orders.lookup`, or `tools.context7["resolve-library-id"]` for non-identifier segments), so each `path` is directly usable as the call site. An empty query browses the catalog alphabetically by path; combined with `namespace` (`{ query: "", namespace: "orders" }`) it lists everything in that namespace. A query that names one tool path exactly (canonical path, `tools.`-prefixed path, or rendered JavaScript expression) is treated as a lookup and returns that tool alone.
 
-The instructions are structured markdown, ordered so the workflow sits at the top and the catalog at the bottom: a `## Workflow` section with numbered steps (find a tool via search when the catalog is partial, or pick from the inlined list when it is complete; call the exact path as-is; return only the needed fields), a `## Rules` section holding only guidance the workflow does not already cover (only listed/search-result Code Mode tools and internal runtime tools exist inside `tools`; filter and aggregate collections in code; narrow `Promise<unknown>` results at runtime; run independent calls through `Promise.all`; enumerate `tools` with `Object.keys`/`for...in`; browse a namespace and paginate search results when search is advertised), a short `## Language` section that identifies the runtime as a restricted JavaScript orchestration language and names its major unavailable capabilities, and the budgeted `## Available tools` catalog. Example call forms use explicit `<namespace>.<tool>`/`<field>` placeholders - never a real or fabricated tool name.
+The instructions are structured markdown, ordered so the workflow sits at the top and the catalog at the bottom: a `## Workflow` section with numbered steps (find a tool via search when the catalog is partial, or pick from the inlined list when it is complete; call the exact path as-is; `JSON.parse` string results; return only the needed fields), a `## Rules` section holding only guidance the workflow does not already cover (only listed/search-result tools exist inside `tools`; filter and aggregate collections in code; treat `Promise<unknown>` results as shapeless until verified; run independent calls through `Promise.all`; enumerate `tools` with `Object.keys`/`for...in`; browse a namespace via search when it is advertised), a short `## Syntax` section that assumes standard JavaScript and names only what is unusual (TypeScript annotations stripped; the data-boundary serialization of Date/Map/Set/RegExp) or missing (classes, generators, `for await...of`, `.then`/`.catch`/`.finally`), and the budgeted `## Available tools` catalog. Example call forms use explicit `<namespace>.<tool>`/`<field>` placeholders - never a real or fabricated tool name.
 
 A host cannot define its own `$codemode` top-level namespace.
 
@@ -241,15 +209,14 @@ CodeMode executes a deliberately bounded JavaScript subset. It supports:
 - `if`, conditional expressions, `switch`, `for`, `for...of` (arrays, strings, Maps, Sets), `for...in` (own keys of plain objects, index strings of arrays, and namespace/tool names of `tools` references - anything else is an error suggesting `for...of` or `Object.keys`, rather than real JS's surprising behavior of indices for strings and zero iterations for Maps/Sets), `while`, and `do...while`.
 - Arrow functions and function declarations with closures, defaults, rest parameters, and destructuring.
 - Optional chaining, nullish coalescing, templates, spread (arrays, strings, Maps, Sets), and `try`/`catch`.
-- Common array, string, number, `Object`, `Math`, and `JSON` operations. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces, including `$codemode`, and `Object.keys(tools.ns)` lists the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
+- Common array, string, number, `Object`, `Math`, and `JSON` operations. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces and `Object.keys(tools.ns)` the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
 - `Date` - `Date.now()`/`Date.parse()`/`Date.UTC()`, `new Date(...)`, the getter methods, and date arithmetic/comparison via the time value. Dates stringify as ISO (`toString` included, for determinism across host timezones).
-- Regular expressions - `/literals/` and `new RegExp(...)` with `test`/`exec` (stateful `lastIndex` for `g`), plus string `match`/`matchAll`/`replace`/`replaceAll`/`split`/`search` with patterns. Match results are arrays carrying `index` and named `groups` as own properties (`input` is omitted). `replace` and `replaceAll` accept function replacers with captures, offset, input, and named groups; callbacks run sequentially, may await tool calls, and have their results coerced to strings. Invalid patterns, invalid flags, and missing-`g` calls fail with catchable errors that say what was wrong and how to fix it (escaping hints, the exact `/pattern/g` to write). Patterns run on the host engine, so pathological backtracking is bounded only by the execution timeout.
+- Regular expressions - `/literals/` and `new RegExp(...)` with `test`/`exec` (stateful `lastIndex` for `g`), plus string `match`/`matchAll`/`replace`/`replaceAll`/`split`/`search` with patterns. Match results are arrays carrying `index` and named `groups` as own properties (`input` is omitted). Invalid patterns, invalid flags, and missing-`g` calls fail with catchable errors that say what was wrong and how to fix it (escaping hints, the exact `/pattern/g` to write). Patterns run on the host engine, so pathological backtracking is bounded only by the execution timeout. Function replacers are not supported.
 - `Map` and `Set` - construction from entries/arrays/strings, `get`/`set`/`add`/`has`/`delete`/`clear`/`size`/`forEach`, and `keys`/`values`/`entries` returning **arrays** (not iterators).
-- URL helpers - `URL` resolution and mutation, linked `URLSearchParams`, `URL.canParse`/`URL.parse`, URI and URI-component encoding/decoding, and query parameter construction, lookup, mutation, sorting, callbacks, and materialization. URLSearchParams iteration methods return arrays, matching the Map/Set convention.
 - First-class promises - an un-awaited `tools.ns.tool(...)` is a promise value whose call starts immediately on a supervised fiber; `await` resolves it (awaiting a non-promise value is a no-op, and `return tools.ns.tool(...)` resolves like an async-function return). `Promise.all`, `Promise.allSettled`, and `Promise.race` accept any array mixing promises and plain values (built inline, beforehand, or via spread); `Promise.resolve`/`Promise.reject` construct settled promises. `Promise.allSettled` rejection reasons are the same plain `{ name?, message }` data a `catch` binding sees, and `Promise.race` interrupts its losing in-flight calls. At most 8 tool calls run concurrently. When a program completes, still-running un-awaited calls are awaited before the execution ends; a failure from a call that was never awaited surfaces as an unhandled-rejection diagnostic.
-- `throw value` and `throw new Error(message)` for explicit program failure. `Error` (and `TypeError`/`RangeError`/`SyntaxError`/`ReferenceError`/`EvalError`/`URIError`) are real constructors, callable with or without `new`; error values are plain `{ name, message }` data that additionally satisfy `instanceof Error` (a specific type matches itself and `Error`, as in JS). Every caught failure - thrown errors, interpreter runtime errors, and tool failures - is `instanceof Error` in a `catch` block; a thrown non-error value (`throw "text"`) is not, matching JS. Caught failures carry the `name` the equivalent real-JS failure would have - `JSON.parse` and invalid regex patterns produce a `SyntaxError` (satisfying `instanceof SyntaxError`), an unknown identifier a `ReferenceError`, assigning to a constant a `TypeError`, a bad `normalize` form a `RangeError`; failures with no specific analogue (including tool failures) are named `"Error"`. `instanceof` also recognizes `Date`, `RegExp`, `Map`, `Set`, `URL`, `URLSearchParams`, `Array`, `Object`, and `Promise`; any other right-hand side is a catchable error.
+- `throw value` and `throw new Error(message)` for explicit program failure. `Error` (and `TypeError`/`RangeError`/`SyntaxError`/`ReferenceError`/`EvalError`/`URIError`) are real constructors, callable with or without `new`; error values are plain `{ name, message }` data that additionally satisfy `instanceof Error` (a specific type matches itself and `Error`, as in JS). Every caught failure - thrown errors, interpreter runtime errors, and tool failures - is `instanceof Error` in a `catch` block; a thrown non-error value (`throw "text"`) is not, matching JS. Caught failures carry the `name` the equivalent real-JS failure would have - `JSON.parse` and invalid regex patterns produce a `SyntaxError` (satisfying `instanceof SyntaxError`), an unknown identifier a `ReferenceError`, assigning to a constant a `TypeError`, a bad `normalize` form a `RangeError`; failures with no specific analogue (including tool failures) are named `"Error"`. `instanceof` also recognizes `Date`, `RegExp`, `Map`, `Set`, `Array`, `Object`, and `Promise`; any other right-hand side is a catchable error.
 
-Inside a program, standard-library values stay live everywhere: the internal data checkpoints (`Object.*` helpers, spread, coercion inputs) preserve the instances, so `Object.values({ d: date })[0].getTime()` and a spread copy of an object holding a Map keep working. Only at the host boundary (final result, tool arguments, `JSON.stringify`) do they serialize exactly as `JSON.stringify` would: Date and URL become strings (an invalid Date becomes `null`), while RegExp, Map, Set, and URLSearchParams become `{}`. Promise values never cross a data boundary: an un-awaited promise in a result or tool argument produces a diagnostic that says to await it, instead of serializing to `{}`.
+Inside a program, Date/RegExp/Map/Set values stay live everywhere: the internal data checkpoints (`Object.*` helpers, spread, coercion inputs) preserve the instances, so `Object.values({ d: date })[0].getTime()` and a spread copy of an object holding a Map keep working. Only at the host boundary (final result, tool arguments, `JSON.stringify`) do the four value types serialize exactly as `JSON.stringify` would: a Date becomes its ISO string (`null` when invalid) and RegExp/Map/Set become `{}`. Promise values never cross a data boundary: an un-awaited promise in a result or tool argument produces a diagnostic that says to await it, instead of serializing to `{}`.
 
 It does not expose `eval`, dynamic imports, modules, classes, generators, timers, host globals, prototype mutation, custom promise constructors (`new Promise`), promise chaining (`.then`/`.catch`/`.finally` - `await` with `try`/`catch` is the supported style), or arbitrary method calls. Unsupported syntax returns an `UnsupportedSyntax` diagnostic with a source location when available.
 
@@ -312,7 +279,7 @@ import { toolError } from "@opencode-ai/codemode"
 run: ({ id }) => (authorized(id) ? loadOrder(id) : Effect.fail(toolError("Order is unavailable")))
 ```
 
-Only the supplied message is model-visible. The optional cause is never returned in `CodeMode.Result`; hosts should perform any required internal logging before crossing this boundary.
+Only the supplied message is model-visible. The optional cause is never returned in `ExecuteResult`; hosts should perform any required internal logging before crossing this boundary.
 
 ## Authority Boundary
 
@@ -341,10 +308,12 @@ A program cannot gain authority through prose or generated code. It can only exe
 The public contract is guided by these equivalences:
 
 - `CodeMode.execute({ ...options, code })` is equivalent to `CodeMode.make(options).execute(code)`.
+- `CodeMode.make(options).agentTool().execute({ code })` is equivalent to `CodeMode.make(options).execute(code)`.
+- `CodeMode.make(options).agentTool().description` equals `CodeMode.make(options).instructions()`.
 - A tool implementation is not invoked unless its input has decoded successfully.
 - A tool result is not visible to the program unless its output has decoded and crossed the plain-data boundary successfully.
 - Unknown host failures do not become model-visible diagnostics; `ToolError` is the explicit safe-message channel.
-- Host interruption remains interruption rather than a `CodeMode.Failure`.
+- Host interruption remains interruption rather than an `ExecuteFailure`.
 
 ## Non-Goals
 

packages/codemode/src/index.ts

@@ -1,4 +1,21 @@
-export * as CodeMode from "./codemode.js"
-export * as Tool from "./tool.js"
-export * as OpenAPI from "./openapi/index.js"
-export { ToolError, toolError } from "./tool-error.js"
+export { ToolError, CodeMode, ExecuteInputSchema, ExecuteResultSchema, toolError } from "./codemode.js"
+export { Tool } from "./tool.js"
+export type { Definition as ToolDefinition, JsonSchema, ToolSchema } from "./tool.js"
+export type { ToolCallEnded, ToolCallHooks } from "./tool-runtime.js"
+export type {
+  AgentToolDefinition,
+  CodeModeOptions,
+  CodeModeRuntime,
+  DataValue,
+  Diagnostic,
+  DiagnosticKind,
+  DiscoveryOptions,
+  ExecuteFailure,
+  ExecuteOptions,
+  ExecuteResult,
+  ExecuteSuccess,
+  ExecutionLimits,
+  ToolCall,
+  ToolCallStarted,
+  ToolDescription,
+} from "./codemode.js"

packages/codemode/src/interpreter/model.ts

@@ -1,200 +0,0 @@
-import type { SafeObject } from "../tool-runtime.js"
-import type { SandboxURL } from "../values.js"
-
-export type SourcePosition = {
-  line: number
-  column: number
-}
-
-export type SourceLocation = {
-  start: SourcePosition
-  end: SourcePosition
-}
-
-export type AstNode = {
-  type: string
-  loc?: SourceLocation
-  [key: string]: unknown
-}
-
-export type ProgramNode = AstNode & {
-  type: "Program"
-  body: Array<AstNode>
-}
-
-export type Binding = {
-  mutable: boolean
-  value: unknown
-  initialized?: boolean
-}
-
-export type StatementResult =
-  | { kind: "none" }
-  | { kind: "value"; value: unknown }
-  | { kind: "return"; value: unknown }
-  | { kind: "break" }
-  | { kind: "continue" }
-
-export type MemberReference = {
-  target: SafeObject | Array<unknown> | SandboxURL
-  key: string | number
-}
-
-export class CodeModeFunction {
-  constructor(
-    readonly parameters: ReadonlyArray<AstNode>,
-    readonly body: AstNode,
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>,
-  ) {}
-}
-
-export class IntrinsicReference {
-  constructor(
-    readonly receiver: unknown,
-    readonly name: string,
-  ) {}
-}
-
-export class ComputedValue {
-  constructor(readonly value: unknown) {}
-}
-
-export class PromiseNamespace {}
-
-export type PromiseMethodName = "all" | "allSettled" | "race" | "resolve" | "reject"
-
-export class PromiseMethodReference {
-  constructor(readonly name: PromiseMethodName) {}
-}
-
-export type GlobalNamespaceName =
-  | "Object"
-  | "Math"
-  | "JSON"
-  | "Array"
-  | "console"
-  | "Date"
-  | "RegExp"
-  | "Map"
-  | "Set"
-  | "URL"
-  | "URLSearchParams"
-
-export class GlobalNamespace {
-  constructor(readonly name: GlobalNamespaceName) {}
-}
-
-export class GlobalMethodReference {
-  constructor(
-    readonly namespace: GlobalNamespaceName | "Number" | "String",
-    readonly name: string,
-  ) {}
-}
-
-export class CoercionFunction {
-  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat") {}
-}
-
-export class UriFunction {
-  constructor(readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent") {}
-}
-
-export class ProgramThrow {
-  constructor(readonly value: unknown) {}
-}
-
-export class ErrorConstructorReference {
-  constructor(readonly name: string) {}
-}
-
-export type DiagnosticKind =
-  | "ParseError"
-  | "UnsupportedSyntax"
-  | "UnknownTool"
-  | "InvalidToolInput"
-  | "InvalidToolOutput"
-  | "InvalidDataValue"
-  | "ToolCallLimitExceeded"
-  | "TimeoutExceeded"
-  | "ToolFailure"
-  | "ExecutionFailure"
-
-export const OptionalShortCircuit: unique symbol = Symbol("codemode.optional-short-circuit")
-
-export const supportedSyntaxMessage =
-  "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, and Promise.all/allSettled/race/resolve/reject over arrays mixing promises and plain values for parallel tool calls (promise chaining with .then/.catch is not supported - use await with try/catch)."
-
-export class InterpreterRuntimeError extends Error {
-  readonly node?: AstNode
-  errorName: string = "Error"
-
-  constructor(
-    message: string,
-    node?: AstNode,
-    readonly kind: DiagnosticKind = "ExecutionFailure",
-    readonly suggestions?: ReadonlyArray<string>,
-  ) {
-    super(message)
-    this.name = "InterpreterRuntimeError"
-    if (node) this.node = node
-  }
-
-  as(errorName: string): this {
-    this.errorName = errorName
-    return this
-  }
-}
-
-export const unsupportedSyntax = (kind: string, node: AstNode): InterpreterRuntimeError =>
-  new InterpreterRuntimeError(
-    `Syntax '${kind}' is not supported in CodeMode. ${supportedSyntaxMessage}`,
-    node,
-    "UnsupportedSyntax",
-    [supportedSyntaxMessage],
-  )
-
-export const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null
-
-export const asNode = (value: unknown, context: string): AstNode => {
-  if (!isRecord(value) || typeof value.type !== "string") {
-    throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`)
-  }
-  return value as AstNode
-}
-
-export const getArray = (node: AstNode, key: string): Array<unknown> => {
-  const value = node[key]
-  if (!Array.isArray(value)) throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node)
-  return value
-}
-
-export const getString = (node: AstNode, key: string): string => {
-  const value = node[key]
-  if (typeof value !== "string") throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node)
-  return value
-}
-
-export const getBoolean = (node: AstNode, key: string): boolean => {
-  const value = node[key]
-  if (typeof value !== "boolean") throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node)
-  return value
-}
-
-export const getOptionalNode = (node: AstNode, key: string): AstNode | undefined => {
-  const value = node[key]
-  if (value === undefined || value === null) return undefined
-  return asNode(value, key)
-}
-
-export const getNode = (node: AstNode, key: string): AstNode => asNode(node[key], key)
-
-export const sourceLocation = (node: AstNode): { readonly line: number; readonly column: number } => ({
-  line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
-  column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
-})
-
-export const formatLocation = (node?: AstNode): string => {
-  if (!node?.loc) return ""
-  const location = sourceLocation(node)
-  return ` (line ${location.line}, col ${location.column})`
-}

packages/codemode/src/openapi/TODO.md

@@ -1,19 +0,0 @@
-# OpenAPI Follow-ups
-
-The initial adapter intentionally skips operations it cannot execute correctly. Future work may add:
-
-- Cookie parameters, authentication, and cookie-header merging.
-- Matrix, label, space-delimited, pipe-delimited, `allowReserved`, and parameter `content` serialization.
-- External references and complete nested `$defs` support.
-- Relative or templated server URLs and server variables.
-- Base URLs containing query strings or fragments.
-- Runtime response-schema validation and full content negotiation.
-- Binary response values and explicit byte-oriented return types.
-- Request/response projection for `readOnly` and `writeOnly` properties.
-- SSE, WebSocket, and other streaming transports.
-- Recovery of responses rejected by a status-filtering `HttpClient`.
-- Configurable request and response size limits.
-- Adapter-enforced redirect policy independent of the supplied `HttpClient`.
-- Strict UTF-8 and empty-body validation for JSON responses.
-- Compile-time rejection of parameter schemas with nested values unsupported by their serialization style; runtime rejects them before auth resolution.
-- Complete malformed-security-scheme validation and broader auth-combination coverage.

packages/codemode/src/openapi/index.ts

@@ -1,130 +0,0 @@
-import { HttpClient } from "effect/unstable/http"
-import { make, type Definition } from "../tool.js"
-import { invoke } from "./runtime.js"
-import {
-  componentDefinitions,
-  inputSchema,
-  isRecord,
-  methods,
-  nonEmptyString,
-  operationInput,
-  operationOutput,
-  operationPath,
-  operationSecurityRequirements,
-  securityRequirements,
-  securitySchemes,
-  specServerUrl,
-  validateBaseUrl,
-} from "./spec.js"
-import type { Operation, Options, Result, Skipped, Tools } from "./types.js"
-
-export type {
-  AuthResolver,
-  Credential,
-  Document,
-  Operation,
-  Options,
-  Result,
-  SecurityScheme,
-  Skipped,
-  Tools,
-} from "./types.js"
-
-/**
- * Builds a CodeMode tool subtree from an OpenAPI 3.x document, one tool per
- * operation. Auth is resolved host-side via `auth.resolve` and never
- * model-visible. Tools require `HttpClient.HttpClient`; unrepresentable
- * operations land in `skipped`.
- */
-export const fromSpec = (options: Options): Result => {
-  const document = options.spec
-  const schemes = securitySchemes(document)
-  const defaultSecurity = securityRequirements(document.security)
-  const definitions = componentDefinitions(document)
-  const paths = isRecord(document.paths) ? document.paths : {}
-  const used = new Set<string>()
-  const namespaces = new Set<string>()
-  const skipped: Array<Skipped> = []
-  const tools = Object.create(null) as Tools
-
-  for (const [path, pathValue] of Object.entries(paths)) {
-    if (!isRecord(pathValue)) continue
-    for (const [method, operationValue] of Object.entries(pathValue)) {
-      if (!methods.has(method) || !isRecord(operationValue)) continue
-      const segments = operationPath(method, path, operationValue, used, namespaces)
-      const operation: Operation = {
-        operationId: nonEmptyString(operationValue.operationId),
-        method: method.toUpperCase(),
-        path,
-        summary: nonEmptyString(operationValue.summary),
-        description: nonEmptyString(operationValue.description),
-      }
-      const output = operationOutput(document, operationValue, definitions)
-      if (!output.ok) {
-        skipped.push({ method: operation.method, path, reason: output.reason })
-        continue
-      }
-
-      const resolvedBaseUrl = (() => {
-        if (options.baseUrl !== undefined) return validateBaseUrl(options.baseUrl)
-        if (operationValue.servers !== undefined) return specServerUrl(operationValue)
-        if (pathValue.servers !== undefined) return specServerUrl(pathValue)
-        return specServerUrl(document)
-      })()
-      if (!resolvedBaseUrl.ok) {
-        skipped.push({ method: operation.method, path, reason: resolvedBaseUrl.reason })
-        continue
-      }
-      const parsedInput = operationInput(document, pathValue, operationValue)
-      if (!parsedInput.ok) {
-        skipped.push({ method: operation.method, path, reason: parsedInput.reason })
-        continue
-      }
-      const input = parsedInput.value
-
-      const security = operationSecurityRequirements(operationValue.security, defaultSecurity, schemes)
-      if (!security.ok) {
-        skipped.push({ method: operation.method, path, reason: security.reason })
-        continue
-      }
-      const plan = {
-        operation,
-        url: `${resolvedBaseUrl.value.replace(/\/+$/, "")}${path}`,
-        fields: input.fields,
-        body: input.body,
-        security: security.value,
-        schemes,
-        auth: options.auth,
-        headers: options.headers ?? {},
-      }
-      used.add(segments.join("."))
-      for (const index of segments.slice(0, -1).keys()) namespaces.add(segments.slice(0, index + 1).join("."))
-      setTool(
-        tools,
-        segments,
-        make({
-          description: operation.description ?? operation.summary ?? `${operation.method} ${path}`,
-          input: inputSchema(input.fields, definitions),
-          output: output.value,
-          run: (input) => invoke(plan, input),
-        }),
-      )
-    }
-  }
-
-  return { tools, skipped }
-}
-
-const setTool = (tools: Tools, path: ReadonlyArray<string>, definition: Definition<HttpClient.HttpClient>): void => {
-  const [head, ...rest] = path
-  if (head === undefined) return
-  if (rest.length === 0) {
-    tools[head] = definition
-    return
-  }
-  const child = tools[head]
-  if (child === undefined || !isRecord(child) || child._tag === "CodeModeTool") {
-    tools[head] = Object.create(null) as Tools
-  }
-  setTool(tools[head] as Tools, rest, definition)
-}

packages/codemode/src/openapi/runtime.ts

@@ -1,324 +0,0 @@
-import { Effect, Option, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse, type HttpMethod } from "effect/unstable/http"
-import { ToolError, toolError } from "../tool-error.js"
-import { isRecord, own } from "./spec.js"
-import type { AppliedAuth, Credential, Plan, SecurityScheme } from "./types.js"
-
-const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
-const maxErrorBodyChars = 1_024
-const maxResponseBodyBytes = 50 * 1024 * 1024
-
-export const invoke = (plan: Plan, input: unknown): Effect.Effect<unknown, unknown, HttpClient.HttpClient> =>
-  Effect.gen(function* () {
-    const value = isRecord(input) ? input : {}
-
-    let request = yield* buildRequest(plan, value)
-
-    const auth = yield* resolveAuth(plan)
-    for (const [name, item] of Object.entries(auth.query)) {
-      request = HttpClientRequest.setUrlParam(request, name, item)
-    }
-    request = HttpClientRequest.setHeaders(request, auth.headers)
-
-    const client = yield* HttpClient.HttpClient
-    const response = yield* client
-      .execute(request)
-      .pipe(
-        Effect.catch((cause) =>
-          Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed: transport error`, cause)),
-        ),
-      )
-    const text = yield* readResponseBody(response, plan)
-    const mediaType = response.headers["content-type"]?.split(";")[0]?.trim().toLowerCase()
-    const json = mediaType === "application/json" || mediaType?.endsWith("+json") === true
-    const decoded = text === "" ? Option.some(null) : json ? decodeJson(text) : Option.none()
-    const parsed = json ? Option.getOrElse(decoded, () => text) : text === "" ? null : text
-    if (response.status < 200 || response.status >= 300) {
-      const rendered = typeof parsed === "string" ? parsed : (JSON.stringify(parsed) ?? "")
-      const summary =
-        rendered === "" || rendered === "null"
-          ? "no response body"
-          : rendered.length > maxErrorBodyChars
-            ? `${rendered.slice(0, maxErrorBodyChars)}...`
-            : rendered
-      return yield* Effect.fail(
-        toolError(`${plan.operation.method} ${plan.operation.path} failed with HTTP ${response.status}: ${summary}`),
-      )
-    }
-    if (json && Option.isNone(decoded)) {
-      return yield* Effect.fail(
-        toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`),
-      )
-    }
-    return parsed
-  })
-
-const buildRequest = (
-  plan: Plan,
-  input: Readonly<Record<string, unknown>>,
-): Effect.Effect<HttpClientRequest.HttpClientRequest, ToolError> =>
-  Effect.gen(function* () {
-    // Validate every model-controlled value before auth resolution, which may refresh tokens.
-    const url = buildUrl(plan, input)
-    if (url instanceof ToolError) return yield* Effect.fail(url)
-    const missing = plan.fields.find(
-      (field) => field.required && field.location !== "path" && own(input, field.inputName) === undefined,
-    )
-    if (missing !== undefined) {
-      const label = missing.location === "body" ? "body field" : `${missing.location} parameter`
-      return yield* Effect.fail(toolError(`Missing required ${label} '${missing.inputName}'.`))
-    }
-
-    let request = HttpClientRequest.make(plan.operation.method as HttpMethod.HttpMethod)(url)
-    for (const field of plan.fields) {
-      if (field.location !== "query") continue
-      const item = own(input, field.inputName)
-      if (item === undefined) continue
-      const serialized = serializeQuery(request, field, item)
-      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
-      request = serialized
-    }
-
-    // Host headers first, then declared header parameters.
-    request = HttpClientRequest.setHeaders(request, plan.headers)
-    for (const field of plan.fields) {
-      if (field.location !== "header") continue
-      const item = own(input, field.inputName)
-      if (item === undefined) continue
-      const serialized = serializeSimple(field, item, String)
-      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
-      request = HttpClientRequest.setHeader(request, field.name, serialized)
-    }
-
-    const setBody = (value: unknown, mediaType: string) =>
-      HttpClientRequest.bodyJson(request, value).pipe(
-        Effect.map((next) => HttpClientRequest.setHeader(next, "content-type", mediaType)),
-        Effect.mapError((cause) =>
-          toolError(`Invalid JSON body for ${plan.operation.method} ${plan.operation.path}.`, cause),
-        ),
-      )
-    if (plan.body?.mode === "value") {
-      const field = plan.fields.find((field) => field.location === "body")
-      const body = field === undefined ? undefined : own(input, field.inputName)
-      if (body !== undefined) request = yield* setBody(body, plan.body.mediaType)
-    }
-    if (plan.body?.mode === "object") {
-      const entries = plan.fields.flatMap((field) => {
-        if (field.location !== "body") return []
-        const item = own(input, field.inputName)
-        return item === undefined ? [] : [[field.name, item] as const]
-      })
-      if (plan.body.required || entries.length > 0) {
-        request = yield* setBody(Object.fromEntries(entries), plan.body.mediaType)
-      }
-    }
-    return request
-  })
-
-const resolveAuth = (plan: Plan): Effect.Effect<AppliedAuth, unknown> =>
-  Effect.gen(function* () {
-    const none: AppliedAuth = { headers: {}, query: {} }
-    if (plan.security.length === 0) return none
-
-    const unavailable: Array<string> = []
-    alternatives: for (const requirement of plan.security) {
-      const names = Object.keys(requirement)
-      if (names.length === 0) return none
-      const credentials: Array<readonly [string, SecurityScheme, Credential]> = []
-      for (const name of names) {
-        const scheme = own(plan.schemes, name)
-        if (scheme === undefined || plan.auth === undefined) {
-          unavailable.push(name)
-          continue alternatives
-        }
-        const credential = yield* plan.auth.resolve({
-          name,
-          definition: scheme,
-          scopes: requirement[name] ?? [],
-          operation: plan.operation,
-        })
-        if (credential === undefined) {
-          unavailable.push(name)
-          continue alternatives
-        }
-        credentials.push([name, scheme, credential])
-      }
-      const applied = applyCredentials(credentials)
-      return applied instanceof ToolError ? yield* Effect.fail(applied) : applied
-    }
-
-    return yield* Effect.fail(
-      toolError(
-        `${plan.operation.method} ${plan.operation.path} requires authentication; no credential available for: ${[...new Set(unavailable)].join(", ")}.`,
-      ),
-    )
-  })
-
-const applyCredentials = (
-  credentials: ReadonlyArray<readonly [string, SecurityScheme, Credential]>,
-): AppliedAuth | ToolError => {
-  const headers = new Map<string, string>()
-  const query = new Map<string, string>()
-  const add = (carrier: "header" | "query", name: string, value: string): ToolError | undefined => {
-    const target = carrier === "header" ? headers : query
-    if (target.has(name)) return toolError(`Authentication resolves multiple credentials for ${carrier} '${name}'.`)
-    target.set(name, value)
-  }
-  for (const [name, definition, credential] of credentials) {
-    if (credential.type === "bearer") {
-      const duplicate = add("header", "authorization", `Bearer ${credential.token}`)
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    if (credential.type === "basic") {
-      // Buffer instead of btoa: btoa throws on non-Latin-1 credentials.
-      const duplicate = add(
-        "header",
-        "authorization",
-        `Basic ${Buffer.from(`${credential.username}:${credential.password}`, "utf8").toString("base64")}`,
-      )
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    if (credential.type === "header") {
-      const duplicate = add("header", credential.name.toLowerCase(), credential.value)
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    // apiKey: the carrier comes from the scheme declaration.
-    if (definition.type !== "apiKey") {
-      return toolError(
-        `Security scheme '${name}' is not an apiKey scheme; resolve a bearer, basic, or header credential for it.`,
-      )
-    }
-    if (definition.in === "cookie") return toolError(`Cookie authentication '${name}' is not supported.`)
-    const parameter = definition.in === "header" ? definition.name.toLowerCase() : definition.name
-    const duplicate = add(definition.in, parameter, credential.value)
-    if (duplicate !== undefined) return duplicate
-  }
-  return { headers: Object.fromEntries(headers), query: Object.fromEntries(query) }
-}
-
-const buildUrl = (plan: Plan, input: Readonly<Record<string, unknown>>): string | ToolError => {
-  let url = plan.url
-  for (const field of plan.fields) {
-    if (field.location !== "path") continue
-    const item = own(input, field.inputName)
-    if (item === undefined) {
-      return toolError(`Missing required path parameter '${field.inputName}'.`)
-    }
-    const fieldValue = serializeSimple(field, item, (value) =>
-      encodeURIComponent(value).replace(/[!'()*]/g, (character) =>
-        `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
-      ),
-    )
-    if (fieldValue instanceof ToolError) return fieldValue
-    // '.'/'..' survive encoding and URL normalization collapses them, letting a
-    // model-supplied value retarget the request to a different endpoint.
-    if (fieldValue === "" || fieldValue === "." || fieldValue === "..") {
-      return toolError(`Invalid path parameter '${field.inputName}'.`)
-    }
-    url = url.replaceAll(`{${field.name}}`, fieldValue)
-  }
-  const unresolved = url.match(/\{[^{}]+\}/)
-  if (unresolved !== null) return toolError(`Unresolved path parameter ${unresolved[0]}.`)
-  return url
-}
-
-const serializeSimple = (
-  field: Plan["fields"][number],
-  value: unknown,
-  encode: (value: string) => string,
-): string | ToolError => {
-  const scalar = (item: unknown): string | ToolError =>
-    item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean"
-      ? toolError(`Parameter '${field.inputName}' contains an unsupported nested value.`)
-      : encode(String(item))
-  if (Array.isArray(value)) {
-    const items = value.map(scalar)
-    const invalid = items.find((item): item is ToolError => item instanceof ToolError)
-    return invalid ?? items.join(",")
-  }
-  if (!isRecord(value)) return scalar(value)
-  const entries = Object.entries(value).flatMap<string | ToolError>(([name, item]) => {
-    const rendered = scalar(item)
-    if (rendered instanceof ToolError) return [rendered]
-    return field.explode ? [`${encode(name)}=${rendered}`] : [encode(name), rendered]
-  })
-  const invalid = entries.find((item): item is ToolError => item instanceof ToolError)
-  return invalid ?? entries.join(",")
-}
-
-const serializeQuery = (
-  request: HttpClientRequest.HttpClientRequest,
-  field: Plan["fields"][number],
-  value: unknown,
-): HttpClientRequest.HttpClientRequest | ToolError => {
-  if (field.style === "deepObject") {
-    if (!isRecord(value)) return toolError(`Deep-object parameter '${field.inputName}' must be an object.`)
-    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
-      if (current instanceof ToolError) return current
-      if (item === undefined || (item !== null && typeof item === "object")) {
-        return toolError(`Deep-object parameter '${field.inputName}' contains an unsupported nested value.`)
-      }
-      return HttpClientRequest.appendUrlParam(current, `${field.name}[${name}]`, String(item))
-    }, request)
-  }
-  if (Array.isArray(value)) {
-    const rendered = serializeSimple(field, value, String)
-    if (rendered instanceof ToolError) return rendered
-    if (!field.explode) return HttpClientRequest.appendUrlParam(request, field.name, rendered)
-    if (value.some((item) => item === undefined || (item !== null && typeof item === "object"))) {
-      return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
-    }
-    return value.reduce(
-      (current, item) => HttpClientRequest.appendUrlParam(current, field.name, String(item)),
-      request,
-    )
-  }
-  if (isRecord(value) && field.explode) {
-    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
-      if (current instanceof ToolError) return current
-      if (item === undefined || (item !== null && typeof item === "object")) {
-        return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
-      }
-      return HttpClientRequest.appendUrlParam(current, name, String(item))
-    }, request)
-  }
-  const rendered = serializeSimple(field, value, String)
-  return rendered instanceof ToolError ? rendered : HttpClientRequest.appendUrlParam(request, field.name, rendered)
-}
-
-const readResponseBody = (response: HttpClientResponse.HttpClientResponse, plan: Plan): Effect.Effect<string, ToolError> =>
-  Effect.gen(function* () {
-    const contentLength = response.headers["content-length"]
-    const parsedSize = contentLength === undefined ? undefined : Number.parseInt(contentLength, 10)
-    const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
-    if (declaredSize !== undefined && declaredSize > maxResponseBodyBytes) {
-      return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
-    }
-    let body = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, declaredSize ?? 64 * 1024))
-    let size = 0
-    yield* Stream.runForEach(response.stream, (chunk) => {
-      if (size + chunk.byteLength > maxResponseBodyBytes) {
-        return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
-      }
-      if (size + chunk.byteLength > body.byteLength) {
-        const grown = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)))
-        body.copy(grown, 0, 0, size)
-        body = grown
-      }
-      body.set(chunk, size)
-      size += chunk.byteLength
-      return Effect.void
-    }).pipe(
-      Effect.catch((cause) => {
-        if (cause instanceof ToolError) return Effect.fail(cause)
-        if (cause.reason._tag === "EmptyBodyError") return Effect.void
-        return Effect.fail(
-          toolError(`${plan.operation.method} ${plan.operation.path} failed while reading the response body.`, cause),
-        )
-      }),
-    )
-    return new TextDecoder().decode(body.subarray(0, size))
-  })

packages/codemode/src/openapi/spec.ts

@@ -1,507 +0,0 @@
-import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema"
-import type { JsonSchema } from "../tool.js"
-import { isBlockedMember } from "../tool-runtime.js"
-import type {
-  Body,
-  Document,
-  InputField,
-  OperationInput,
-  Parsed,
-  SecurityRequirement,
-  SecurityScheme,
-} from "./types.js"
-
-export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"])
-const parameterLocations = ["path", "query", "header"] as const
-const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"])
-
-export const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const asArray = (value: unknown): ReadonlyArray<unknown> => (Array.isArray(value) ? value : [])
-
-export const nonEmptyString = (value: unknown): string | undefined =>
-  typeof value === "string" && value !== "" ? value : undefined
-
-// Guards record lookups keyed by spec- or model-controlled names against
-// prototype-inherited values (e.g. a parameter named `toString`).
-export const own = <T>(record: Readonly<Record<string, T>>, key: string): T | undefined =>
-  Object.hasOwn(record, key) ? record[key] : undefined
-
-export const resolve = (document: Document, value: unknown): unknown => {
-  const next = (current: unknown, seen: ReadonlySet<string>): unknown => {
-    if (!isRecord(current)) return current
-    const ref = nonEmptyString(current.$ref)
-    if (ref === undefined || !ref.startsWith("#/") || seen.has(ref)) return current
-    const target = ref
-      .slice(2)
-      .split("/")
-      .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
-      .reduce<unknown>((item, segment) => (isRecord(item) ? own(item, segment) : undefined), document)
-    return target === undefined ? current : next(target, new Set([...seen, ref]))
-  }
-  return next(value, new Set())
-}
-
-const projectSchema = (document: Document, value: unknown): JsonSchema => {
-  if (!isRecord(value)) return {}
-  const normalized = nonEmptyString(document.openapi)?.startsWith("3.0")
-    ? fromSchemaOpenApi3_0(value)
-    : fromSchemaOpenApi3_1(value)
-  return Object.keys(normalized.definitions).length === 0
-    ? normalized.schema
-    : { ...normalized.schema, $defs: normalized.definitions }
-}
-
-export const componentDefinitions = (document: Document): Readonly<Record<string, JsonSchema>> => {
-  const components = isRecord(document.components) ? document.components : {}
-  const schemas = isRecord(components.schemas) ? components.schemas : {}
-  return Object.fromEntries(Object.entries(schemas).map(([name, value]) => [name, projectSchema(document, value)]))
-}
-
-const withDefinitions = (schema: JsonSchema, definitions: Readonly<Record<string, JsonSchema>>): JsonSchema => {
-  if (Object.keys(definitions).length === 0) return schema
-  const local = isRecord(schema.$defs) ? schema.$defs : {}
-  return { ...schema, $defs: { ...definitions, ...local } }
-}
-
-const isJsonMediaType = (mediaType: string): boolean => {
-  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
-  return normalized === "application/json" || normalized.endsWith("+json")
-}
-
-const isBinaryMediaType = (document: Document, mediaType: string, value: unknown): boolean => {
-  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
-  if (!isJsonMediaType(normalized) && !normalized.startsWith("text/")) return true
-  if (!isRecord(value)) return false
-  const schema = resolve(document, value.schema)
-  return isRecord(schema) && schema.format === "binary"
-}
-
-const jsonContent = (content: Record<string, unknown>): { readonly mediaType: string; readonly schema: unknown } | undefined => {
-  const entry = Object.entries(content).find(([mediaType]) => isJsonMediaType(mediaType))
-  return entry !== undefined && isRecord(entry[1]) ? { mediaType: entry[0], schema: entry[1].schema } : undefined
-}
-
-const isFlattenableObjectBody = (
-  schema: unknown,
-  requestRequired: boolean,
-): schema is Record<string, unknown> & { readonly properties: Record<string, unknown> } =>
-  isRecord(schema) &&
-  requestRequired &&
-  schema.type === "object" &&
-  isRecord(schema.properties) &&
-  schema.additionalProperties === false &&
-  schema.nullable !== true &&
-  schema.allOf === undefined &&
-  schema.anyOf === undefined &&
-  schema.oneOf === undefined
-
-type PlannedField = Omit<InputField, "inputName">
-
-const operationParameters = (
-  document: Document,
-  pathItem: Record<string, unknown>,
-  operation: Record<string, unknown>,
-): Parsed<ReadonlyArray<PlannedField>> => {
-  // Operation-level parameters override path-level ones sharing (location, name).
-  const declared = new Map<
-    string,
-    { readonly name: string; readonly location: string; readonly parameter: Record<string, unknown> }
-  >()
-  for (const raw of [...asArray(pathItem.parameters), ...asArray(operation.parameters)]) {
-    const resolved = resolve(document, raw)
-    if (!isRecord(resolved)) return { ok: false, reason: "parameter declaration is invalid or unresolved" }
-    const name = nonEmptyString(resolved.name)
-    const location = nonEmptyString(resolved.in)
-    if (name === undefined || location === undefined)
-      return { ok: false, reason: "parameter declaration is missing name or location" }
-    declared.set(`${location}:${name}`, { name, location, parameter: resolved })
-  }
-  const unordered: Array<PlannedField> = []
-  for (const item of declared.values()) {
-    const name = item.name
-    const location = item.location
-    const resolved = item.parameter
-    if (location === "cookie") return { ok: false, reason: `cookie parameter '${name}' is not supported` }
-    if (location !== "path" && location !== "query" && location !== "header") {
-      return { ok: false, reason: `parameter '${name}' uses unsupported location '${location}'` }
-    }
-    if (location === "header" && ignoredHeaderParameters.has(name.toLowerCase())) continue
-    if (resolved.schema === undefined && resolved.content === undefined) {
-      return { ok: false, reason: `parameter '${name}' declares neither schema nor content` }
-    }
-    if (resolved.content !== undefined)
-      return { ok: false, reason: `parameter '${name}' uses unsupported content encoding` }
-    if (resolved.style !== undefined && nonEmptyString(resolved.style) === undefined) {
-      return { ok: false, reason: `parameter '${name}' has an invalid style` }
-    }
-    if (resolved.explode !== undefined && typeof resolved.explode !== "boolean") {
-      return { ok: false, reason: `parameter '${name}' has an invalid explode value` }
-    }
-    if (resolved.allowReserved !== undefined && typeof resolved.allowReserved !== "boolean") {
-      return { ok: false, reason: `parameter '${name}' has an invalid allowReserved value` }
-    }
-    if (resolved.allowReserved === true)
-      return { ok: false, reason: `parameter '${name}' uses unsupported allowReserved encoding` }
-    const declaredStyle = nonEmptyString(resolved.style) ?? (location === "query" ? "form" : "simple")
-    if (location === "query" && declaredStyle !== "form" && declaredStyle !== "deepObject") {
-      return { ok: false, reason: `query parameter '${name}' uses unsupported style '${declaredStyle}'` }
-    }
-    if (location !== "query" && declaredStyle !== "simple") {
-      return { ok: false, reason: `${location} parameter '${name}' uses unsupported style '${declaredStyle}'` }
-    }
-    const style = declaredStyle === "deepObject" ? "deepObject" : declaredStyle === "form" ? "form" : "simple"
-    const explode = typeof resolved.explode === "boolean" ? resolved.explode : style === "form"
-    if (style === "deepObject" && !explode) {
-      return { ok: false, reason: `query parameter '${name}' uses deepObject with explode=false` }
-    }
-    const base = projectSchema(document, resolved.schema)
-    const description = nonEmptyString(resolved.description)
-    unordered.push({
-      name,
-      location,
-      required: resolved.required === true || location === "path",
-      style,
-      explode,
-      schema: {
-        ...base,
-        ...(base.description === undefined && description !== undefined ? { description } : {}),
-      },
-    })
-  }
-  return {
-    ok: true,
-    value: parameterLocations.flatMap((location) => unordered.filter((field) => field.location === location)),
-  }
-}
-
-const operationBody = (
-  document: Document,
-  operation: Record<string, unknown>,
-): Parsed<{ readonly fields: ReadonlyArray<PlannedField>; readonly body: Body | undefined }> => {
-  const resolved = resolve(document, operation.requestBody)
-  if (!isRecord(resolved)) return { ok: true, value: { fields: [], body: undefined } }
-  const content = isRecord(resolved.content) ? resolved.content : {}
-  const selected = jsonContent(content)
-  if (selected === undefined) {
-    return {
-      ok: false,
-      reason: `request body has no JSON content (declared: ${Object.keys(content).join(", ") || "none"})`,
-    }
-  }
-  const schema = resolve(document, selected.schema)
-  const required = resolved.required === true
-  if (!isFlattenableObjectBody(schema, required)) {
-    return {
-      ok: true,
-      value: {
-        fields: [
-          {
-            name: "body",
-            location: "body",
-            required,
-            schema: projectSchema(document, selected.schema),
-            style: undefined,
-            explode: undefined,
-          },
-        ],
-        body: { required, mode: "value", mediaType: selected.mediaType },
-      },
-    }
-  }
-  const requiredProperties = new Set(
-    Array.isArray(schema.required) ? schema.required.filter((item): item is string => typeof item === "string") : [],
-  )
-  return {
-    ok: true,
-    value: {
-      fields: Object.entries(schema.properties).map(([name, value]) => ({
-        name,
-        location: "body" as const,
-        required: required && requiredProperties.has(name),
-        schema: projectSchema(document, value),
-        style: undefined,
-        explode: undefined,
-      })),
-      body: { required, mode: "object", mediaType: selected.mediaType },
-    },
-  }
-}
-
-export const operationInput = (
-  document: Document,
-  pathItem: Record<string, unknown>,
-  operation: Record<string, unknown>,
-): Parsed<OperationInput> => {
-  const parameters = operationParameters(document, pathItem, operation)
-  if (!parameters.ok) return parameters
-  const requestBody = operationBody(document, operation)
-  if (!requestBody.ok) return requestBody
-  const fields = [...parameters.value, ...requestBody.value.fields]
-
-  const conflicts = new Set(
-    [...Map.groupBy(fields, (field) => field.name)]
-      .filter(([, matches]) => new Set(matches.map((field) => field.location)).size > 1)
-      .map(([name]) => name),
-  )
-  const used = new Set<string>()
-  return {
-    ok: true,
-    value: {
-      fields: fields.map((field) => {
-        const visibleName = isBlockedMember(field.name) ? `${field.name}_2` : field.name
-        const base = conflicts.has(field.name) ? `${field.location}_${visibleName}` : visibleName
-        const next = (index: number): string => {
-          const candidate = index === 1 ? base : `${base}_${index}`
-          return used.has(candidate) ? next(index + 1) : candidate
-        }
-        const inputName = next(1)
-        used.add(inputName)
-        return { ...field, inputName }
-      }),
-      body: requestBody.value.body,
-    },
-  }
-}
-
-export const inputSchema = (
-  fields: ReadonlyArray<InputField>,
-  definitions: Readonly<Record<string, JsonSchema>>,
-): JsonSchema => {
-  const required = fields.filter((field) => field.required).map((field) => field.inputName)
-  return withDefinitions(
-    {
-      type: "object",
-      properties: Object.fromEntries(fields.map((field) => [field.inputName, field.schema])),
-      ...(required.length === 0 ? {} : { required }),
-    },
-    definitions,
-  )
-}
-
-const successfulResponses = (
-  document: Document,
-  operation: Record<string, unknown>,
-): Parsed<ReadonlyArray<Record<string, unknown>>> => {
-  if (!isRecord(operation.responses)) return { ok: true, value: [] }
-  const entries = Object.entries(operation.responses)
-  const selected = [
-    ...entries.filter(([status]) => /^2\d\d$/.test(status)).sort(([a], [b]) => a.localeCompare(b)),
-    ...entries.filter(([status]) => status.toUpperCase() === "2XX"),
-  ]
-  const responses: Array<Record<string, unknown>> = []
-  for (const [, value] of selected) {
-    const resolved = resolve(document, value)
-    if (!isRecord(resolved) || nonEmptyString(resolved.$ref) !== undefined) {
-      return { ok: false, reason: "successful response declaration is invalid or unresolved" }
-    }
-    responses.push(resolved)
-  }
-  return { ok: true, value: responses }
-}
-
-export const operationOutput = (
-  document: Document,
-  operation: Record<string, unknown>,
-  definitions: Readonly<Record<string, JsonSchema>>,
-): Parsed<JsonSchema | undefined> => {
-  if (operation["x-websocket"] === true) return { ok: false, reason: "WebSocket operations are not supported" }
-  const responses = successfulResponses(document, operation)
-  if (!responses.ok) return responses
-  const streams = responses.value.some(
-    (response) =>
-      isRecord(response.content) &&
-      Object.keys(response.content).some(
-        (mediaType) => mediaType.split(";")[0]?.trim().toLowerCase() === "text/event-stream",
-      ),
-  )
-  if (streams) return { ok: false, reason: "SSE operations are not supported" }
-  const binary = responses.value.some(
-    (response) =>
-      isRecord(response.content) &&
-      Object.entries(response.content).some(([mediaType, value]) => isBinaryMediaType(document, mediaType, value)),
-  )
-  if (binary) return { ok: false, reason: "binary responses are not supported" }
-
-  const outcomes: Array<JsonSchema> = []
-  for (const response of responses.value) {
-    if (response.content !== undefined && !isRecord(response.content)) return { ok: true, value: undefined }
-    const content = isRecord(response.content) ? response.content : {}
-    if (Object.keys(content).length === 0) {
-      outcomes.push({ type: "null" })
-      continue
-    }
-    for (const [mediaType, value] of Object.entries(content)) {
-      if (!isJsonMediaType(mediaType)) {
-        outcomes.push({ type: "string" })
-        continue
-      }
-      if (!isRecord(value) || value.schema === undefined) return { ok: true, value: undefined }
-      outcomes.push(projectSchema(document, value.schema))
-    }
-  }
-  if (outcomes.length === 0) return { ok: true, value: undefined }
-  return {
-    ok: true,
-    value: withDefinitions(outcomes.length === 1 ? outcomes[0] ?? {} : { anyOf: outcomes }, definitions),
-  }
-}
-
-const sanitizeOperationSegment = (raw: string): string => {
-  const base =
-    raw
-      .replaceAll(/[^A-Za-z0-9_$]+/g, "_")
-      .replace(/^_+|_+$/g, "")
-      .replace(/^([0-9])/, "_$1") || "operation"
-  return isBlockedMember(base) ? `${base}_2` : base
-}
-
-const fallbackOperationId = (method: string, path: string): string =>
-  [
-    method,
-    ...path
-      .split("/")
-      .filter((part) => part !== "")
-      .flatMap((part) => (part.startsWith("{") && part.endsWith("}") ? ["by", part.slice(1, -1)] : [part]))
-      .flatMap((part) => part.split(/[^A-Za-z0-9]+/).filter((word) => word !== "")),
-  ]
-    .map((word, index) => {
-      const lower = word.toLowerCase()
-      return index === 0 ? lower : `${lower.charAt(0).toUpperCase()}${lower.slice(1)}`
-    })
-    .join("")
-
-export const operationPath = (
-  method: string,
-  path: string,
-  operation: Record<string, unknown>,
-  used: ReadonlySet<string>,
-  namespaces: ReadonlySet<string>,
-): ReadonlyArray<string> => {
-  const raw = nonEmptyString(operation.operationId)
-  const segments = (raw === undefined ? [fallbackOperationId(method, path)] : raw.split(".")).map(sanitizeOperationSegment)
-  if (isOperationPathAvailable(segments, used, namespaces)) return segments
-  const conflict = segments.slice(0, -1).findIndex((_, index) => used.has(segments.slice(0, index + 1).join(".")))
-  if (conflict >= 0 && conflict + 1 < segments.length) {
-    const collapsed = segments.flatMap((segment, index) => {
-      if (index === conflict) {
-        const next = segments[index + 1] ?? ""
-        return [`${segment}${next.charAt(0).toUpperCase()}${next.slice(1)}`]
-      }
-      return index === conflict + 1 ? [] : [segment]
-    })
-    if (isOperationPathAvailable(collapsed, used, namespaces)) return collapsed
-  }
-  const fallback = segments.join("_")
-  const next = (index: number): string => {
-    const candidate = `${fallback}_${index}`
-    return isOperationPathAvailable([candidate], used, namespaces) ? candidate : next(index + 1)
-  }
-  return [next(2)]
-}
-
-const isOperationPathAvailable = (
-  segments: ReadonlyArray<string>,
-  used: ReadonlySet<string>,
-  namespaces: ReadonlySet<string>,
-): boolean => {
-  const key = segments.join(".")
-  if (used.has(key) || namespaces.has(key)) return false
-  return segments.slice(0, -1).every((_, index) => !used.has(segments.slice(0, index + 1).join(".")))
-}
-
-export const specServerUrl = (source: Record<string, unknown>): Parsed<string> => {
-  const server = asArray(source.servers).find(isRecord)
-  const url = server === undefined ? undefined : nonEmptyString(server.url)
-  if (url === undefined) return { ok: false, reason: "spec declares no servers; pass baseUrl" }
-  if (/\{[^{}]+\}/.test(url)) {
-    return { ok: false, reason: `server URL '${url}' is not an absolute URL; pass baseUrl` }
-  }
-  return validateBaseUrl(url)
-}
-
-export const validateBaseUrl = (value: string): Parsed<string> => {
-  if (!/^https?:\/\//i.test(value)) return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
-  const url = URL.parse(value)
-  if (url === null || (url.protocol !== "http:" && url.protocol !== "https:")) {
-    return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
-  }
-  if (url.search !== "" || url.hash !== "") {
-    return { ok: false, reason: `server URL '${value}' contains an unsupported query string or fragment` }
-  }
-  return { ok: true, value }
-}
-
-export const securityRequirements = (value: unknown): Parsed<ReadonlyArray<SecurityRequirement>> => {
-  if (value === undefined) return { ok: true, value: [] }
-  if (!Array.isArray(value)) return { ok: false, reason: "security declaration is not an array" }
-  const requirements: Array<SecurityRequirement> = []
-  for (const item of value) {
-    if (!isRecord(item)) return { ok: false, reason: "security requirement is not an object" }
-    const requirement = Object.create(null) as Record<string, ReadonlyArray<string>>
-    for (const [name, scopes] of Object.entries(item)) {
-      if (!Array.isArray(scopes)) return { ok: false, reason: "security requirement scopes are not string arrays" }
-      const parsed = scopes.filter((scope): scope is string => typeof scope === "string")
-      if (parsed.length !== scopes.length) {
-        return { ok: false, reason: "security requirement scopes are not string arrays" }
-      }
-      requirement[name] = parsed
-    }
-    requirements.push(requirement)
-  }
-  return { ok: true, value: requirements }
-}
-
-export const operationSecurityRequirements = (
-  value: unknown,
-  defaults: Parsed<ReadonlyArray<SecurityRequirement>>,
-  schemes: Readonly<Record<string, SecurityScheme>>,
-): Parsed<ReadonlyArray<SecurityRequirement>> => {
-  const parsed = value === undefined ? defaults : securityRequirements(value)
-  if (!parsed.ok) return parsed
-  const supported = parsed.value.filter((requirement) =>
-    Object.keys(requirement).every((name) => {
-      const scheme = own(schemes, name)
-      return scheme !== undefined && !(scheme.type === "apiKey" && scheme.in === "cookie")
-    }),
-  )
-  if (parsed.value.length === 0 || supported.length > 0) return { ok: true, value: supported }
-
-  const names = [...new Set(parsed.value.flatMap((requirement) => Object.keys(requirement)))]
-  const cookieScheme = names.find((name) => {
-    const definition = own(schemes, name)
-    return definition?.type === "apiKey" && definition.in === "cookie"
-  })
-  return {
-    ok: false,
-    reason:
-      cookieScheme === undefined
-        ? `security requirement references missing or malformed scheme: ${names.join(", ")}`
-        : `cookie authentication '${cookieScheme}' is not supported`,
-  }
-}
-
-export const securitySchemes = (document: Document): Readonly<Record<string, SecurityScheme>> => {
-  const components = isRecord(document.components) ? document.components : {}
-  const declared = isRecord(components.securitySchemes) ? components.securitySchemes : {}
-  return Object.fromEntries(
-    Object.entries(declared).flatMap<readonly [string, SecurityScheme]>(([name, value]) => {
-      const resolved = resolve(document, value)
-      if (!isRecord(resolved)) return []
-      const type = nonEmptyString(resolved.type)
-      if (type === "apiKey") {
-        const carrier = nonEmptyString(resolved.in)
-        const parameter = nonEmptyString(resolved.name)
-        if (parameter === undefined || (carrier !== "header" && carrier !== "query" && carrier !== "cookie")) return []
-        return [[name, { type, name: parameter, in: carrier }] as const]
-      }
-      if (type === "http") {
-        const scheme = nonEmptyString(resolved.scheme)?.toLowerCase()
-        return scheme === undefined ? [] : [[name, { type, scheme }] as const]
-      }
-      if (type === "oauth2" || type === "openIdConnect") return [[name, { type }] as const]
-      return []
-    }),
-  )
-}

packages/codemode/src/openapi/types.ts

@@ -1,112 +0,0 @@
-import { Effect } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import type { Definition, JsonSchema } from "../tool.js"
-
-/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
-export type Document = Record<string, unknown>
-
-/** The operation identity handed to auth resolution and errors. */
-export type Operation = {
-  readonly operationId: string | undefined
-  readonly method: string
-  readonly path: string
-  readonly summary: string | undefined
-  readonly description: string | undefined
-}
-
-/** A resolved OpenAPI security scheme from `components.securitySchemes`. */
-export type SecurityScheme =
-  | { readonly type: "apiKey"; readonly name: string; readonly in: "header" | "query" | "cookie" }
-  | { readonly type: "http"; readonly scheme: string }
-  | { readonly type: "oauth2" }
-  | { readonly type: "openIdConnect" }
-
-/**
- * Credential material returned by a host auth resolver. The carrier for `apiKey`
- * comes from the scheme definition, not the credential. `header` is the escape
- * hatch for nonstandard schemes.
- */
-export type Credential =
-  | { readonly type: "bearer"; readonly token: string }
-  | { readonly type: "basic"; readonly username: string; readonly password: string }
-  | { readonly type: "apiKey"; readonly value: string }
-  | { readonly type: "header"; readonly name: string; readonly value: string }
-
-/**
- * Resolves credential material for one named security scheme at call time.
- * `undefined` means unavailable, try the next OR alternative; a failure aborts
- * the call rather than falling through.
- */
-export type AuthResolver = (context: {
-  readonly name: string
-  readonly definition: SecurityScheme
-  readonly scopes: ReadonlyArray<string>
-  readonly operation: Operation
-}) => Effect.Effect<Credential | undefined, unknown>
-
-export type Options = {
-  readonly spec: Document
-  /** Overrides all document, path, and operation `servers`. Required when no applicable absolute server URL exists. */
-  readonly baseUrl?: string | undefined
-  /** Host credential resolution, keyed by security scheme name. */
-  readonly auth?: { readonly resolve: AuthResolver } | undefined
-  /** Static headers on every request. Not model-visible; declared header params may override them, auth always wins. */
-  readonly headers?: Readonly<Record<string, string>> | undefined
-}
-
-/** An operation that could not be represented as a tool, and why. */
-export type Skipped = {
-  readonly method: string
-  readonly path: string
-  readonly reason: string
-}
-
-export type Tools = { [name: string]: Definition<HttpClient.HttpClient> | Tools }
-
-export type Result = {
-  /** Tool subtree; the host places it under a key in its `tools` tree. */
-  readonly tools: Tools
-  readonly skipped: ReadonlyArray<Skipped>
-}
-
-export type Parsed<T> = { readonly ok: true; readonly value: T } | { readonly ok: false; readonly reason: string }
-
-export type InputLocation = "path" | "query" | "header" | "body"
-
-export type InputField = {
-  /** Model-visible field name after cross-location collision handling. */
-  readonly inputName: string
-  /** Original parameter or body-property name used on the wire. */
-  readonly name: string
-  readonly location: InputLocation
-  readonly required: boolean
-  readonly schema: JsonSchema
-  readonly style: "simple" | "form" | "deepObject" | undefined
-  readonly explode: boolean | undefined
-}
-
-export type Body = { readonly required: boolean; readonly mode: "object" | "value"; readonly mediaType: string }
-
-export type OperationInput = {
-  readonly fields: ReadonlyArray<InputField>
-  readonly body: Body | undefined
-}
-
-/** One OR alternative: scheme name -> required scopes. Empty object = unauthenticated is acceptable. */
-export type SecurityRequirement = Readonly<Record<string, ReadonlyArray<string>>>
-
-export type Plan = {
-  readonly operation: Operation
-  readonly url: string
-  readonly fields: ReadonlyArray<InputField>
-  readonly body: Body | undefined
-  readonly security: ReadonlyArray<SecurityRequirement>
-  readonly schemes: Readonly<Record<string, SecurityScheme>>
-  readonly auth: { readonly resolve: AuthResolver } | undefined
-  readonly headers: Readonly<Record<string, string>>
-}
-
-export type AppliedAuth = {
-  readonly headers: Readonly<Record<string, string>>
-  readonly query: Readonly<Record<string, string>>
-}

packages/codemode/src/stdlib/collections.ts

@@ -1,51 +0,0 @@
-export const arrayMethods = new Set([
-  "map",
-  "filter",
-  "find",
-  "findIndex",
-  "findLast",
-  "findLastIndex",
-  "some",
-  "every",
-  "includes",
-  "join",
-  "reduce",
-  "reduceRight",
-  "flatMap",
-  "forEach",
-  "sort",
-  "toSorted",
-  "slice",
-  "concat",
-  "indexOf",
-  "lastIndexOf",
-  "at",
-  "flat",
-  "reverse",
-  "toReversed",
-  "with",
-  "push",
-  "pop",
-  "shift",
-  "unshift",
-  "splice",
-  "fill",
-  "copyWithin",
-  "keys",
-  "values",
-  "entries",
-])
-
-export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"])
-
-export const setMethods = new Set(["add", "has", "delete", "clear", "forEach", "keys", "values", "entries"])
-
-export const spreadItems = (value: unknown): Array<unknown> | undefined => {
-  if (Array.isArray(value)) return value
-  if (typeof value === "string") return Array.from(value)
-  if (value instanceof SandboxMap) return Array.from(value.map.entries(), ([key, item]) => [key, item])
-  if (value instanceof SandboxSet) return Array.from(value.set.values())
-  if (value instanceof SandboxURLSearchParams) return Array.from(value.params.entries(), ([key, item]) => [key, item])
-  return undefined
-}
-import { SandboxMap, SandboxSet, SandboxURLSearchParams } from "../values.js"

packages/codemode/src/stdlib/console.ts

@@ -1,4 +0,0 @@
-export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"])
-
-/** Console formatting recursion ceiling; deeper values render as "...". */
-export const MAX_CONSOLE_DEPTH = 32

packages/codemode/src/stdlib/date.ts

@@ -1,94 +0,0 @@
-export const dateMethods = new Set([
-  "getTime",
-  "valueOf",
-  "toISOString",
-  "toJSON",
-  "toString",
-  "getFullYear",
-  "getMonth",
-  "getDate",
-  "getDay",
-  "getHours",
-  "getMinutes",
-  "getSeconds",
-  "getMilliseconds",
-  "getUTCFullYear",
-  "getUTCMonth",
-  "getUTCDate",
-  "getUTCDay",
-  "getUTCHours",
-  "getUTCMinutes",
-  "getUTCSeconds",
-  "getUTCMilliseconds",
-  "getTimezoneOffset",
-])
-
-export const dateStatics = new Set(["now", "parse", "UTC"])
-
-export const invokeDateStatic = (name: string, args: Array<unknown>, node: AstNode): number => {
-  switch (name) {
-    case "now":
-      return Date.now()
-    case "parse":
-      return Date.parse(coerceToString(args[0]))
-    case "UTC":
-      return Date.UTC(...(args.map((arg) => coerceToNumber(arg)) as Parameters<typeof Date.UTC>))
-    default:
-      throw new InterpreterRuntimeError(`Date.${name} is not available in CodeMode.`, node)
-  }
-}
-
-export const invokeDateMethod = (value: SandboxDate, name: string, node: AstNode): unknown => {
-  const hosted = new Date(value.time)
-  switch (name) {
-    case "getTime":
-    case "valueOf":
-      return value.time
-    case "toISOString":
-      if (!Number.isFinite(value.time)) throw new InterpreterRuntimeError("Invalid time value.", node)
-      return hosted.toISOString()
-    case "toJSON":
-      return Number.isFinite(value.time) ? hosted.toISOString() : null
-    case "toString":
-      return coerceToString(value)
-    case "getFullYear":
-      return hosted.getFullYear()
-    case "getMonth":
-      return hosted.getMonth()
-    case "getDate":
-      return hosted.getDate()
-    case "getDay":
-      return hosted.getDay()
-    case "getHours":
-      return hosted.getHours()
-    case "getMinutes":
-      return hosted.getMinutes()
-    case "getSeconds":
-      return hosted.getSeconds()
-    case "getMilliseconds":
-      return hosted.getMilliseconds()
-    case "getUTCFullYear":
-      return hosted.getUTCFullYear()
-    case "getUTCMonth":
-      return hosted.getUTCMonth()
-    case "getUTCDate":
-      return hosted.getUTCDate()
-    case "getUTCDay":
-      return hosted.getUTCDay()
-    case "getUTCHours":
-      return hosted.getUTCHours()
-    case "getUTCMinutes":
-      return hosted.getUTCMinutes()
-    case "getUTCSeconds":
-      return hosted.getUTCSeconds()
-    case "getUTCMilliseconds":
-      return hosted.getUTCMilliseconds()
-    case "getTimezoneOffset":
-      return hosted.getTimezoneOffset()
-    default:
-      throw new InterpreterRuntimeError(`Date method '${name}' is not available in CodeMode.`, node)
-  }
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { SandboxDate } from "../values.js"
-import { coerceToNumber, coerceToString } from "./value.js"

packages/codemode/src/stdlib/json.ts

@@ -1,42 +0,0 @@
-import {
-  type AstNode,
-  CodeModeFunction,
-  InterpreterRuntimeError,
-  supportedSyntaxMessage,
-} from "../interpreter/model.js"
-import { copyIn, copyOut } from "../tool-runtime.js"
-
-export const jsonStatics = new Set(["stringify", "parse"])
-
-export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  if (!jsonStatics.has(name)) throw new InterpreterRuntimeError(`JSON.${name} is not available in CodeMode.`, node)
-  switch (name) {
-    case "stringify": {
-      const replacer = args[1]
-      if (Array.isArray(replacer) || replacer instanceof CodeModeFunction) {
-        throw new InterpreterRuntimeError(
-          "JSON.stringify replacers are not supported in CodeMode.",
-          node,
-          "UnsupportedSyntax",
-          [supportedSyntaxMessage],
-        )
-      }
-      const space = args[2]
-      const indent = typeof space === "number" || typeof space === "string" ? space : undefined
-      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value")), null, indent)
-    }
-    case "parse": {
-      const text = args[0]
-      if (typeof text !== "string") throw new InterpreterRuntimeError("JSON.parse expects a string.", node)
-      try {
-        return copyIn(JSON.parse(text), "JSON.parse result")
-      } catch (error) {
-        throw new InterpreterRuntimeError(
-          `JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
-          node,
-        ).as("SyntaxError")
-      }
-    }
-  }
-  throw new InterpreterRuntimeError(`JSON.${name} is not available in CodeMode.`, node)
-}

packages/codemode/src/stdlib/math.ts

@@ -1,65 +0,0 @@
-export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"])
-
-export const mathMethods = new Set([
-  "max",
-  "min",
-  "abs",
-  "floor",
-  "ceil",
-  "round",
-  "trunc",
-  "sign",
-  "sqrt",
-  "cbrt",
-  "pow",
-  "hypot",
-  "log",
-  "log2",
-  "log10",
-  "exp",
-])
-
-export const invokeMathMethod = (name: string, args: Array<unknown>, node: AstNode): number => {
-  if (!mathMethods.has(name)) throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node)
-  const nums = args.map((arg) => {
-    if (typeof arg !== "number") throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node)
-    return arg
-  })
-  const [a = Number.NaN, b = Number.NaN] = nums
-  switch (name) {
-    case "max":
-      return Math.max(...nums)
-    case "min":
-      return Math.min(...nums)
-    case "abs":
-      return Math.abs(a)
-    case "floor":
-      return Math.floor(a)
-    case "ceil":
-      return Math.ceil(a)
-    case "round":
-      return Math.round(a)
-    case "trunc":
-      return Math.trunc(a)
-    case "sign":
-      return Math.sign(a)
-    case "sqrt":
-      return Math.sqrt(a)
-    case "cbrt":
-      return Math.cbrt(a)
-    case "pow":
-      return Math.pow(a, b)
-    case "hypot":
-      return Math.hypot(...nums)
-    case "log":
-      return Math.log(a)
-    case "log2":
-      return Math.log2(a)
-    case "log10":
-      return Math.log10(a)
-    case "exp":
-      return Math.exp(a)
-  }
-  throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node)
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"

packages/codemode/src/stdlib/number.ts

@@ -1,66 +0,0 @@
-export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString"])
-
-export const numberConstants = new Set(["MAX_SAFE_INTEGER", "MIN_SAFE_INTEGER", "MAX_VALUE", "MIN_VALUE", "EPSILON"])
-
-export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"])
-
-export const invokeNumberMethod = (value: number, name: string, args: Array<unknown>, node: AstNode): unknown => {
-  const optNum = (index: number): number | undefined => {
-    const arg = args[index]
-    if (arg === undefined) return undefined
-    if (typeof arg !== "number") throw new InterpreterRuntimeError(`Number.${name} expects a number argument.`, node)
-    return arg
-  }
-  let result: unknown
-  switch (name) {
-    case "toFixed":
-      result = value.toFixed(optNum(0))
-      break
-    case "toExponential":
-      result = value.toExponential(optNum(0))
-      break
-    case "toPrecision": {
-      const digits = optNum(0)
-      result = digits === undefined ? value.toString() : value.toPrecision(digits)
-      break
-    }
-    case "toString": {
-      const radix = optNum(0)
-      if (radix !== undefined && (radix < 2 || radix > 36)) {
-        throw new InterpreterRuntimeError("Number.toString radix must be between 2 and 36.", node)
-      }
-      result = value.toString(radix)
-      break
-    }
-    default:
-      throw new InterpreterRuntimeError(`Number method '${name}' is not available in CodeMode.`, node)
-  }
-  return boundedData(result, `Number.${name} result`)
-}
-
-export const invokeNumberStatic = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  const value = args[0]
-  switch (name) {
-    case "isInteger":
-      return Number.isInteger(value)
-    case "isFinite":
-      return Number.isFinite(value)
-    case "isNaN":
-      return Number.isNaN(value)
-    case "isSafeInteger":
-      return Number.isSafeInteger(value)
-    case "parseInt": {
-      const radix = args[1]
-      if (radix !== undefined && typeof radix !== "number") {
-        throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node)
-      }
-      return parseInt(coerceToString(value), radix)
-    }
-    case "parseFloat":
-      return parseFloat(coerceToString(value))
-    default:
-      throw new InterpreterRuntimeError(`Number.${name} is not available in CodeMode.`, node)
-  }
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { boundedData, coerceToString } from "./value.js"

packages/codemode/src/stdlib/object.ts

@@ -1,77 +0,0 @@
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { isBlockedMember } from "../tool-runtime.js"
-import { isSandboxValue, SandboxMap, SandboxURLSearchParams } from "../values.js"
-import { boundedData, coerceToString } from "./value.js"
-
-export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "assign", "fromEntries"])
-
-export const invokeObjectMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  if (!objectStatics.has(name)) throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
-  const requireObject = (): Record<string, unknown> => {
-    const value = boundedData(args[0], `Object.${name} input`)
-    if (isSandboxValue(value)) return {}
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-      throw new InterpreterRuntimeError(`Object.${name} expects a data object.`, node)
-    }
-    return value as Record<string, unknown>
-  }
-  const guardedSet = (out: Record<string, unknown>, key: string, item: unknown): void => {
-    if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available in CodeMode.`, node)
-    out[key] = item
-  }
-  switch (name) {
-    case "keys": {
-      const value = boundedData(args[0], "Object.keys input")
-      if (isSandboxValue(value)) return []
-      if (Array.isArray(value)) return Object.keys(value)
-      if (value === null || typeof value !== "object") {
-        throw new InterpreterRuntimeError("Object.keys expects a data object or array.", node)
-      }
-      return Object.keys(value)
-    }
-    case "values":
-      return Object.values(requireObject())
-    case "entries":
-      return Object.entries(requireObject()).map(([key, item]) => [key, item])
-    case "hasOwn":
-      return Object.hasOwn(requireObject(), String(args[1]))
-    case "assign": {
-      const out: Record<string, unknown> = Object.create(null)
-      for (const source of args) {
-        if (source === null || source === undefined) continue
-        const value = boundedData(source, "Object.assign input")
-        if (isSandboxValue(value)) continue
-        if (value === null || typeof value !== "object" || Array.isArray(value)) {
-          throw new InterpreterRuntimeError("Object.assign expects data objects.", node)
-        }
-        for (const [key, item] of Object.entries(value)) guardedSet(out, key, item)
-      }
-      return out
-    }
-    case "fromEntries": {
-      if (args[0] instanceof SandboxMap) {
-        const out: Record<string, unknown> = Object.create(null)
-        for (const [key, item] of args[0].map.entries()) guardedSet(out, coerceToString(key), item)
-        return out
-      }
-      if (args[0] instanceof SandboxURLSearchParams) {
-        const out: Record<string, unknown> = Object.create(null)
-        for (const [key, value] of args[0].params.entries()) guardedSet(out, key, value)
-        return out
-      }
-      const pairs = boundedData(args[0], "Object.fromEntries input")
-      if (!Array.isArray(pairs)) {
-        throw new InterpreterRuntimeError("Object.fromEntries expects an array of [key, value] pairs.", node)
-      }
-      const out: Record<string, unknown> = Object.create(null)
-      for (const pair of pairs) {
-        if (!Array.isArray(pair)) {
-          throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] pairs.", node)
-        }
-        guardedSet(out, String(pair[0]), pair[1])
-      }
-      return out
-    }
-  }
-  throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
-}

packages/codemode/src/stdlib/promise.ts

@@ -1,6 +0,0 @@
-import type { PromiseMethodName } from "../interpreter/model.js"
-
-export const promiseStatics = new Set<PromiseMethodName>(["all", "allSettled", "race", "resolve", "reject"])
-
-/** Maximum number of eagerly forked tool calls that may run concurrently. */
-export const TOOL_CALL_CONCURRENCY = 8

packages/codemode/src/stdlib/regexp.ts

@@ -1,74 +0,0 @@
-export const regexpMethods = new Set(["test", "exec", "toString"])
-
-export const regexpProperties = new Set([
-  "source",
-  "flags",
-  "lastIndex",
-  "global",
-  "ignoreCase",
-  "multiline",
-  "sticky",
-  "unicode",
-  "dotAll",
-])
-
-export const regexFailureReason = (error: unknown): string =>
-  (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "")
-
-export const escapeRegexHint =
-  'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.'
-
-export const toHostRegex = (arg: unknown, method: string, node: AstNode, extraFlags = ""): RegExp => {
-  if (arg instanceof SandboxRegExp) return arg.regex
-  if (typeof arg === "string") {
-    try {
-      return new RegExp(arg, extraFlags)
-    } catch (error) {
-      throw new InterpreterRuntimeError(
-        `String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`,
-        node,
-      ).as("SyntaxError")
-    }
-  }
-  throw new InterpreterRuntimeError(
-    `String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`,
-    node,
-  )
-}
-
-export const matchToValue = (match: RegExpMatchArray): Array<unknown> => {
-  const result: Array<unknown> = Array.from(match, (group) => group)
-  if (match.index !== undefined) (result as Record<string, unknown> & Array<unknown>).index = match.index
-  if (match.groups) {
-    const groups: SafeObject = Object.create(null) as SafeObject
-    for (const [key, group] of Object.entries(match.groups)) {
-      if (!isBlockedMember(key)) groups[key] = group
-    }
-    ;(result as Record<string, unknown> & Array<unknown>).groups = groups
-  }
-  return result
-}
-
-export const invokeRegExpMethod = (
-  value: SandboxRegExp,
-  name: string,
-  args: Array<unknown>,
-  node: AstNode,
-): unknown => {
-  switch (name) {
-    case "test":
-      return value.regex.test(coerceToString(args[0]))
-    case "exec": {
-      const matched = value.regex.exec(coerceToString(args[0]))
-      return matched === null ? null : matchToValue(matched)
-    }
-    case "toString":
-      return coerceToString(value)
-    default:
-      throw new InterpreterRuntimeError(`RegExp method '${name}' is not available in CodeMode.`, node)
-  }
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { isBlockedMember, type SafeObject } from "../tool-runtime.js"
-import { SandboxRegExp } from "../values.js"
-import { coerceToString } from "./value.js"

packages/codemode/src/stdlib/string.ts

@@ -1,52 +0,0 @@
-export const stringMethods = new Set([
-  "toLowerCase",
-  "toUpperCase",
-  "trim",
-  "trimStart",
-  "trimEnd",
-  "trimLeft",
-  "trimRight",
-  "split",
-  "slice",
-  "substring",
-  "substr",
-  "includes",
-  "startsWith",
-  "endsWith",
-  "indexOf",
-  "lastIndexOf",
-  "replace",
-  "replaceAll",
-  "repeat",
-  "padStart",
-  "padEnd",
-  "charAt",
-  "charCodeAt",
-  "codePointAt",
-  "at",
-  "concat",
-  "toString",
-  "match",
-  "matchAll",
-  "search",
-  "localeCompare",
-  "normalize",
-])
-
-export const stringStatics = new Set(["fromCharCode", "fromCodePoint"])
-
-export const invokeStringStatic = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  const codes = args.map((arg) => {
-    if (typeof arg !== "number") throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node)
-    return arg
-  })
-  switch (name) {
-    case "fromCharCode":
-      return String.fromCharCode(...codes)
-    case "fromCodePoint":
-      return String.fromCodePoint(...codes)
-    default:
-      throw new InterpreterRuntimeError(`String.${name} is not available in CodeMode.`, node)
-  }
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"

packages/codemode/src/stdlib/url.ts

@@ -1,90 +0,0 @@
-export const urlProperties = new Set([
-  "href",
-  "origin",
-  "protocol",
-  "username",
-  "password",
-  "host",
-  "hostname",
-  "port",
-  "pathname",
-  "search",
-  "hash",
-])
-
-export const urlWritableProperties = new Set([
-  "href",
-  "protocol",
-  "username",
-  "password",
-  "host",
-  "hostname",
-  "port",
-  "pathname",
-  "search",
-  "hash",
-])
-
-export const urlMethods = new Set(["toString", "toJSON"])
-export const urlStatics = new Set(["canParse", "parse"])
-export const urlSearchParamsMethods = new Set([
-  "append",
-  "delete",
-  "get",
-  "getAll",
-  "has",
-  "set",
-  "sort",
-  "forEach",
-  "keys",
-  "values",
-  "entries",
-  "toString",
-])
-
-export const uriArgument = (value: unknown, label: string): string => coerceToString(boundedData(value, label))
-
-export const invokeUriFunction = (ref: UriFunction, args: Array<unknown>, node: AstNode): string => {
-  const value = uriArgument(args[0], `${ref.name} input`)
-  try {
-    switch (ref.name) {
-      case "encodeURI":
-        return encodeURI(value)
-      case "encodeURIComponent":
-        return encodeURIComponent(value)
-      case "decodeURI":
-        return decodeURI(value)
-      case "decodeURIComponent":
-        return decodeURIComponent(value)
-    }
-  } catch (error) {
-    throw new InterpreterRuntimeError(
-      `${ref.name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`,
-      node,
-    ).as("URIError")
-  }
-}
-
-export const urlArgument = (value: unknown, label: string): string =>
-  value instanceof SandboxURL ? value.url.href : uriArgument(value, label)
-
-export const invokeURLStatic = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  if (!urlStatics.has(name)) throw new InterpreterRuntimeError(`URL.${name} is not available in CodeMode.`, node)
-  if (args.length === 0) throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node).as("TypeError")
-  const input = urlArgument(args[0], `URL.${name} input`)
-  const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`)
-  try {
-    const url = new URL(input, base)
-    return name === "canParse" ? true : new SandboxURL(url)
-  } catch {
-    return name === "canParse" ? false : null
-  }
-}
-
-export const invokeURLMethod = (value: SandboxURL, name: string, node: AstNode): string => {
-  if (name === "toString" || name === "toJSON") return value.url.href
-  throw new InterpreterRuntimeError(`URL method '${name}' is not available in CodeMode.`, node)
-}
-import { type AstNode, InterpreterRuntimeError, UriFunction } from "../interpreter/model.js"
-import { SandboxURL } from "../values.js"
-import { boundedData, coerceToString } from "./value.js"

packages/codemode/src/stdlib/value.ts

@@ -1,90 +0,0 @@
-export const errorConstructors = new Set([
-  "Error",
-  "TypeError",
-  "RangeError",
-  "SyntaxError",
-  "ReferenceError",
-  "EvalError",
-  "URIError",
-])
-
-export const valueConstructors = new Set(["Date", "RegExp", "Map", "Set", "URL", "URLSearchParams"])
-
-export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="])
-
-const ErrorBrand: unique symbol = Symbol("codemode.error")
-
-export const createErrorValue = (name: string, message: string): SafeObject => {
-  const value = Object.assign(Object.create(null) as SafeObject, { name, message })
-  Object.defineProperty(value, ErrorBrand, { value: name })
-  return value
-}
-
-export const errorBrandName = (value: unknown): string | undefined =>
-  value !== null && typeof value === "object"
-    ? ((value as Record<PropertyKey, unknown>)[ErrorBrand] as string | undefined)
-    : undefined
-
-export const boundedData = (value: unknown, label: string): unknown => copyIn(value, label, true)
-
-export const coerceToString = (value: unknown): string => {
-  if (value === null) return "null"
-  if (value === undefined) return "undefined"
-  if (value instanceof SandboxDate)
-    return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date"
-  if (value instanceof SandboxRegExp) return `/${value.regex.source}/${value.regex.flags}`
-  if (value instanceof SandboxMap) return "[object Map]"
-  if (value instanceof SandboxSet) return "[object Set]"
-  if (value instanceof SandboxURL) return value.url.href
-  if (value instanceof SandboxURLSearchParams) return value.params.toString()
-  if (typeof value === "object") {
-    return Array.isArray(value)
-      ? value.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",")
-      : "[object Object]"
-  }
-  return String(value)
-}
-
-export const coerceToNumber = (value: unknown): number => {
-  if (value instanceof SandboxDate) return value.time
-  if (isSandboxValue(value)) return Number.NaN
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? Number.NaN : Number(value)
-}
-
-export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node: AstNode): unknown => {
-  const raw = args[0]
-  if (isSandboxValue(raw)) {
-    if (ref.name === "Boolean") return true
-    if (ref.name === "Number") return coerceToNumber(raw)
-    if (ref.name === "String") return coerceToString(raw)
-    if (ref.name === "parseInt") return parseInt(coerceToString(raw))
-    return parseFloat(coerceToString(raw))
-  }
-  const value = boundedData(args[0], `${ref.name} input`)
-  if (ref.name === "Number") return coerceToNumber(value)
-  if (ref.name === "Boolean") return Boolean(value)
-  if (ref.name === "parseInt") {
-    const radix = args[1]
-    if (radix !== undefined && typeof radix !== "number") {
-      throw new InterpreterRuntimeError("parseInt expects a numeric radix.", node)
-    }
-    return parseInt(coerceToString(value), radix)
-  }
-  if (ref.name === "parseFloat") return parseFloat(coerceToString(value))
-  return coerceToString(value)
-}
-import {
-  type AstNode,
-  CoercionFunction,
-  InterpreterRuntimeError,
-} from "../interpreter/model.js"
-import { copyIn, type SafeObject } from "../tool-runtime.js"
-import {
-  isSandboxValue,
-  SandboxDate,
-  SandboxMap,
-  SandboxRegExp,
-  SandboxSet,
-  SandboxURL,
-  SandboxURLSearchParams,
-} from "../values.js"

packages/codemode/src/token.ts

@@ -0,0 +1,10 @@
+/**
+ * Token estimation for budgeting model-facing text. Copied from
+ * `@opencode-ai/core/util/token` (chars / 4) so this package stays
+ * dependency-free; keep the two in sync if the heuristic ever changes.
+ */
+export * as Token from "./token.js"
+
+const CHARS_PER_TOKEN = 4
+
+export const estimate = (input: string) => Math.max(0, Math.round(input.length / CHARS_PER_TOKEN))

packages/codemode/src/tool-runtime.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Schema } from "effect"
+import { Cause, Effect } from "effect"
 import { ToolError, toolError } from "./tool-error.js"
 import {
   decodeInput as decodeToolInput,
@@ -6,20 +6,12 @@ import {
   identifierSegment,
   inputProperties,
   inputTypeScript,
+  isDefinition as isToolDefinition,
   outputTypeScript,
-} from "./tool-schema.js"
-import { isDefinition as isToolDefinition, type Definition } from "./tool.js"
-import {
-  SandboxDate,
-  SandboxMap,
-  SandboxPromise,
-  SandboxRegExp,
-  SandboxSet,
-  SandboxURL,
-  SandboxURLSearchParams,
-} from "./values.js"
-
-const estimateTokens = (input: string) => Math.max(0, Math.round(input.length / 4))
+  type Definition,
+} from "./tool.js"
+import { estimate } from "./token.js"
+import { SandboxDate, SandboxMap, SandboxPromise, SandboxRegExp, SandboxSet } from "./values.js"
 
 export type HostTool<R = never> = (...args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
 
@@ -27,22 +19,18 @@ export type HostTools<R = never> = {
   [name: string]: HostTool<R> | Definition<R> | HostTools<R>
 }
 
-export type Services<Tools> = ServicesOf<Tools, []>
-
-type ServicesOf<Tools, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8
-  ? never
-  : Tools extends (...args: Array<unknown>) => Effect.Effect<unknown, unknown, infer R>
+export type Services<Tools> = Tools extends (...args: Array<unknown>) => Effect.Effect<unknown, unknown, infer R>
+  ? R
+  : Tools extends {
+        readonly _tag: "CodeModeTool"
+        readonly run: (input: unknown) => Effect.Effect<unknown, unknown, infer R>
+      }
     ? R
-    : Tools extends {
-          readonly _tag: "CodeModeTool"
-          readonly run: (input: unknown) => Effect.Effect<unknown, unknown, infer R>
-        }
-      ? R
-      : Tools extends object
-        ? string extends keyof Tools
-          ? ServicesOf<Tools[string], [...Depth, unknown]>
-          : ServicesOf<Tools[keyof Tools], [...Depth, unknown]>
-        : never
+    : Tools extends object
+      ? string extends keyof Tools
+        ? never
+        : Services<Tools[keyof Tools]>
+      : never
 
 /** Minimal audit record retained for each admitted tool call. */
 export type ToolCall = {
@@ -83,26 +71,10 @@ export type ToolDescription = {
 export type SafeObject = Record<string, unknown>
 
 const reservedNamespace = "$codemode"
-const defaultCatalogBudget = 2_000
+const defaultMaxInlineCatalogTokens = 2_000
 const defaultSearchLimit = 10
-const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0))
-const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
-const SearchInput = Schema.Struct({
-  query: Schema.optionalKey(Schema.String),
-  namespace: Schema.optionalKey(Schema.String),
-  limit: Schema.optionalKey(PositiveInt),
-  offset: Schema.optionalKey(NonNegativeInt),
-})
-const SearchItem = Schema.Struct({
-  path: Schema.String,
-  description: Schema.String,
-  signature: Schema.String,
-})
-const SearchOutput = Schema.Struct({
-  items: Schema.Array(SearchItem),
-  remaining: NonNegativeInt,
-  next: Schema.NullOr(Schema.Struct({ offset: NonNegativeInt })),
-})
+const searchSignature =
+  "tools.$codemode.search({ query?: string, namespace?: string, limit?: number }): Promise<{ items: Array<{ path: string; description: string; signature: string }>; total: number }>"
 const toolExpression = (path: string) =>
   "tools" +
   path
@@ -160,9 +132,9 @@ export const isBlockedMember = (name: string): boolean => blockedMemberNames.has
  * Two modes share the walk:
  * - **Boundary** (`preserveSandboxValues` false, the default): the host<->sandbox boundary -
  *   final results, tool-call arguments, `JSON.stringify`. Sandbox value types serialize
- *   exactly as JSON.stringify would: Date/URL -> strings, the remaining value types -> {}.
+ *   exactly as JSON.stringify would: Date -> ISO string (invalid -> null), RegExp/Map/Set -> {}.
  * - **Intra-sandbox checkpoint** (`preserveSandboxValues` true; see `boundedData` in
- *   codemode.ts): standard-library value instances pass through untouched (treated as leaves,
+ *   codemode.ts): Date/RegExp/Map/Set instances pass through untouched (treated as leaves,
  *   contents not walked), so values flowing through `Object.*` helpers, coercion inputs, and
  *   other in-sandbox checkpoints stay fully usable (`.getTime()`, `.has()`, ...).
  *
@@ -216,9 +188,7 @@ const copyBounded = (
       value instanceof SandboxDate ||
       value instanceof SandboxRegExp ||
       value instanceof SandboxMap ||
-      value instanceof SandboxSet ||
-      value instanceof SandboxURL ||
-      value instanceof SandboxURLSearchParams
+      value instanceof SandboxSet
     ) {
       return value
     }
@@ -238,30 +208,24 @@ const copyBounded = (
       for (const item of value.values()) wrapped.set.add(copyBounded(item, label, depth + 1, seen, true))
       return wrapped
     }
-    if (value instanceof URL) return new SandboxURL(new URL(value.href))
-    if (value instanceof URLSearchParams) return new SandboxURLSearchParams(new URLSearchParams(value))
   }
 
   // Sandbox value types (and their host counterparts, which a host tool may legitimately
-  // return) serialize exactly as JSON.stringify would at the data boundary: Date/URL use
-  // toJSON(), while RegExp/Map/Set/URLSearchParams have no JSON form beyond {}.
+  // return) serialize exactly as JSON.stringify would at the data boundary: a Date is its
+  // toJSON() ISO string (invalid -> null), and RegExp/Map/Set have no JSON form beyond {}.
   if (value instanceof SandboxDate) {
     return Number.isFinite(value.time) ? new Date(value.time).toISOString() : null
   }
   if (value instanceof Date) {
     return Number.isFinite(value.getTime()) ? value.toISOString() : null
   }
-  if (value instanceof SandboxURL) return value.url.href
-  if (value instanceof URL) return value.href
   if (
     value instanceof SandboxRegExp ||
     value instanceof SandboxMap ||
     value instanceof SandboxSet ||
-    value instanceof SandboxURLSearchParams ||
     value instanceof RegExp ||
     value instanceof Map ||
-    value instanceof Set ||
-    value instanceof URLSearchParams
+    value instanceof Set
   ) {
     return Object.create(null) as SafeObject
   }
@@ -329,15 +293,14 @@ const definitions = <R>(
 const describeDefinition = <R>(path: string, definition: Definition<R>): ToolDescription => ({
   path,
   description: definition.description,
-  signature: `${toolExpression(path)}(input: ${inputTypeScript(definition, true)}): Promise<${outputTypeScript(definition, true)}>`,
+  signature: `${toolExpression(path)}(input: ${inputTypeScript(definition)}): Promise<${outputTypeScript(definition)}>`,
 })
 
 const visibleDefinitions = <R>(tools: HostTools<R>) =>
-  definitions(tools).map(({ path, definition }) => ({
-    path,
-    definition,
-    description: describeDefinition(path, definition),
-  }))
+  definitions(tools).flatMap(({ path, definition }) => {
+    const description = describeDefinition(path, definition)
+    return [{ path, definition, description }]
+  })
 
 export const catalog = <R>(tools: HostTools<R>): ReadonlyArray<ToolDescription> =>
   visibleDefinitions(tools).map(({ description }) => description)
@@ -350,6 +313,11 @@ export type DiscoveryPlan = {
 
 export type SearchEntry = {
   readonly description: ToolDescription
+  /**
+   * JSDoc-annotated multiline signature shown on search-result items; the compact
+   * single-line form (inline catalog lines) stays in `description.signature`.
+   */
+  readonly signature: string
   /** Top-level namespace (first path segment), matched by the search `namespace` option. */
   readonly namespace: string
   /** Lowercased path + description + input property names/descriptions, for substring matching. */
@@ -383,82 +351,22 @@ const termForms = (term: string): Array<string> => {
   return forms
 }
 
-const makeSearchTool = (searchIndex: ReadonlyArray<SearchEntry>): Definition => ({
-  _tag: "CodeModeTool",
-  description: "Search available Code Mode tools",
-  input: SearchInput,
-  output: SearchOutput,
-  run: (input) =>
-    Effect.sync(() => {
-      const request = input as typeof SearchInput.Type
-      const query = request.query ?? ""
-      const offset = request.offset ?? 0
-      const scoped =
-        request.namespace === undefined
-          ? searchIndex
-          : searchIndex.filter((entry) => entry.namespace === request.namespace)
-      // A query that names one tool path exactly (canonical path or rendered JavaScript
-      // expression) is a lookup, not a search: return that tool alone.
-      const trimmed = query.trim()
-      const pathQuery = trimmed.startsWith("tools.") ? trimmed.slice("tools.".length) : trimmed
-      const exact =
-        pathQuery === ""
-          ? undefined
-          : scoped.find(
-              (entry) => entry.description.path === pathQuery || toolExpression(entry.description.path) === trimmed,
-            )
-      const terms = tokenize(query).map(termForms)
-      // Additive field-weighted scoring, summed across terms: exact path or path segment
-      // (20) > path substring (8) > description substring (4) > any searchable text,
-      // including input parameter names and descriptions (2).
-      const ranked =
-        exact !== undefined
-          ? [exact]
-          : scoped
-              .map((entry) => {
-                const path = entry.description.path.toLowerCase()
-                const description = entry.description.description.toLowerCase()
-                const score = terms.reduce(
-                  (total, forms) =>
-                    total +
-                    (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
-                    (forms.some((form) => path.includes(form)) ? 8 : 0) +
-                    (forms.some((form) => description.includes(form)) ? 4 : 0) +
-                    (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0),
-                  0,
-                )
-                return { entry, score }
-              })
-              .filter(({ score }) => terms.length === 0 || score > 0)
-              .sort(
-                (left, right) =>
-                  right.score - left.score || left.entry.description.path.localeCompare(right.entry.description.path),
-              )
-              .map(({ entry }) => entry)
-      const items = ranked.slice(offset, offset + (request.limit ?? defaultSearchLimit)).map(({ description }) => ({
-        ...description,
-        path: toolExpression(description.path),
-      }))
-      const remaining = Math.max(0, ranked.length - offset - items.length)
-      return {
-        items,
-        remaining,
-        next: remaining > 0 ? { offset: offset + items.length } : null,
-      }
-    }),
-})
+const firstLine = (text: string) => text.split("\n", 1)[0]!.trim()
 
-const searchDescription = describeDefinition(`${reservedNamespace}.search`, makeSearchTool([]))
+/** One-line description used on inline catalog lines; the full text stays in search results. */
+const brief = (text: string, max = 120) => {
+  const line = firstLine(text)
+  return line.length > max ? line.slice(0, max - 1) + "..." : line
+}
 
 const catalogLine = (tool: ToolDescription) => {
-  // Keep the tool description concise; the full schema documentation remains in the signature.
-  const line = tool.description.split("\n", 1)[0]!.trim()
-  const description = line.length > 120 ? line.slice(0, 119) + "..." : line
+  const description = brief(tool.description)
   return description === "" ? `  - ${tool.signature}` : `  - ${tool.signature} // ${description}`
 }
 
 const toSearchEntry = <R>(path: string, definition: Definition<R>, description: ToolDescription): SearchEntry => ({
   description,
+  signature: `${toolExpression(path)}(input: ${inputTypeScript(definition, true)}): Promise<${outputTypeScript(definition, true)}>`,
   namespace: path.split(".", 1)[0]!,
   searchText: [
     path,
@@ -483,7 +391,7 @@ export const assertValidTools = <R>(tools: HostTools<R>): void => {
 
 /**
  * Budgeted catalog: every namespace is always listed with its tool count; full call
- * signatures are inlined against the `catalogBudget` (estimated tokens,
+ * signatures are inlined against the `maxInlineCatalogTokens` budget (estimated tokens,
  * chars/4) round-robin across namespaces - in each round (namespaces alphabetical), every
  * namespace still holding un-inlined tools attempts to place its next-cheapest line, and
  * a namespace whose next line does not fit is done while the others keep going - so every
@@ -492,9 +400,12 @@ export const assertValidTools = <R>(tools: HostTools<R>): void => {
  * namespace. Namespace stub lines are never budgeted: every namespace appears with its
  * tool count even at budget 0.
  */
-export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBudget): DiscoveryPlan => {
-  if (!Number.isSafeInteger(catalogBudget) || catalogBudget < 0) {
-    throw new RangeError("discovery.catalogBudget must be a non-negative safe integer")
+export const discoveryPlan = <R>(
+  tools: HostTools<R>,
+  maxInlineCatalogTokens = defaultMaxInlineCatalogTokens,
+): DiscoveryPlan => {
+  if (!Number.isSafeInteger(maxInlineCatalogTokens) || maxInlineCatalogTokens < 0) {
+    throw new RangeError("discovery.maxInlineCatalogTokens must be a non-negative safe integer")
   }
   const visible = visibleDefinitions(tools)
   const described = visible.map(({ description }) => description)
@@ -519,7 +430,7 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
     picked: new Set<ToolDescription>(),
     queue: [...group].sort(
       (left, right) =>
-        estimateTokens(catalogLine(left)) - estimateTokens(catalogLine(right)) || left.path.localeCompare(right.path),
+        estimate(catalogLine(left)) - estimate(catalogLine(right)) || left.path.localeCompare(right.path),
     ),
   }))
   let used = 0
@@ -528,8 +439,8 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
     const stillActive: typeof active = []
     for (const selection of active) {
       const tool = selection.queue[0]!
-      const cost = estimateTokens(catalogLine(tool))
-      if (used + cost > catalogBudget) continue
+      const cost = estimate(catalogLine(tool))
+      if (used + cost > maxInlineCatalogTokens) continue
       selection.queue.shift()
       selection.picked.add(tool)
       used += cost
@@ -547,17 +458,15 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
 
   // Section order is deliberate: workflow first (the top is the least likely part of a long
   // description to be truncated or skimmed away), then rules, then syntax, with the budgeted
-  // catalog at the bottom. Example call forms use placeholders - never a real or fabricated
-  // tool name - and show both dot and bracket notation so non-identifier names are not normalized.
+  // catalog at the bottom. Example call forms use explicit `<namespace>.<tool>` placeholders -
+  // never a real or fabricated tool name.
   const intro = [
+    "Write a CodeMode program to answer the request. Return code only.",
     empty
-      ? "This is a restricted JavaScript language for calling tools, not a general-purpose runtime."
+      ? "Execute JavaScript in a confined runtime."
       : complete
-        ? "This is a restricted JavaScript language for calling tools, not a general-purpose runtime. Inside the confined interpreter, `tools` contains the Code Mode tools listed below and internal runtime tools; surrounding agent tools are not available."
-        : "This is a restricted JavaScript language for calling tools, not a general-purpose runtime. Inside the confined interpreter, `tools` contains the Code Mode tools listed or searchable below and internal runtime tools; surrounding agent tools are not available.",
-    ...(empty
-      ? []
-      : ["Do not infer or normalize tool names; use only exact signatures shown below or returned by search."]),
+        ? "Execute JavaScript in a confined runtime. Inside this program, `tools` contains only the host-provided tools listed below; surrounding agent tools are not available unless listed here."
+        : "Execute JavaScript in a confined runtime. Inside this program, `tools` contains only the host-provided tools listed or searchable below; surrounding agent tools are not available unless listed here.",
   ]
 
   // The search step exists only when search is advertised (PARTIAL catalog); a COMPLETE
@@ -571,12 +480,16 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
         ...(complete
           ? [
               "1. Pick a tool from the list under `## Available tools` - each line is the exact call signature; use it as-is rather than guessing segments.",
-              "2. Call it using the exact signature shown: `const result = await tools.<namespace>.<tool>(input)`; bracket notation and quotes are part of the path.",
-              "3. Return only the fields you need from structured results; narrow unknown results before reading fields, and avoid returning large raw payloads.",
+              "2. Call it using the exact signature shown: `const res = await tools.<namespace>.<tool>(input)` - bracket notation may appear for names that are not JavaScript identifiers.",
+              '3. Parse text results: `const data = typeof res === "string" ? JSON.parse(res) : res` - most tools return JSON as a string.',
+              "4. Return only the fields you need: `return { <field>: data.<field> }` - raw payloads get truncated and waste context.",
             ]
           : [
-              '1. If needed, discover tools: `return await tools.$codemode.search({ query: "<intent + key nouns>" })`.',
-              "2. In the next execution, copy a returned path exactly, call it, and return only the needed fields.",
+              '1. Find a tool (skip when it is already listed below): `const { items } = await tools.$codemode.search({ query: "<intent + key nouns>" })` - short phrases like "list issues" work best.',
+              "2. Read the matches: each item is `{ path, description, signature }` - read the description before using an unfamiliar tool.",
+              "3. Call it with the result's `path` as-is (never guess segments): `const res = await tools.<namespace>.<tool>(input)` - bracket notation may appear for names that are not JavaScript identifiers.",
+              '4. Parse text results: `const data = typeof res === "string" ? JSON.parse(res) : res` - most tools return JSON as a string.',
+              "5. Return only the fields you need: `return { <field>: data.<field> }` - raw payloads get truncated and waste context.",
             ]),
       ]
 
@@ -587,27 +500,25 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
         "## Rules",
         "",
         complete
-          ? "- Only Code Mode tools listed here and internal runtime tools are available; surrounding agent tools are not implicitly exposed."
-          : "- Only Code Mode tools listed here or returned by `tools.$codemode.search` and internal runtime tools are available; surrounding agent tools are not implicitly exposed.",
+          ? "- Only tools listed here are available inside `tools`; tools from the surrounding agent/runtime are not implicitly exposed."
+          : "- Only tools listed here or returned by `tools.$codemode.search` are available inside `tools`; tools from the surrounding agent/runtime are not implicitly exposed.",
         "- Filter, aggregate, and transform collections in code - never return them raw or call a tool per item across messages.",
-        "- A result typed `Promise<unknown>` may be structured data or text. Before reading fields, check that it is a non-null object and not an array; otherwise handle the returned text or primitive directly.",
-        '- Run independent calls in parallel: `await Promise.all(items.map((item) => tools.<namespace>.<tool>(item)))`, or use `tools.<namespace>["tool-name"](item)` when the listed signature uses bracket notation.',
+        "- A result typed `Promise<unknown>` has no guaranteed shape - verify what actually came back before relying on its fields.",
+        "- Run independent calls in parallel: `await Promise.all(items.map((item) => tools.<namespace>.<tool>(item)))`.",
         "- `Object.keys(tools)` lists namespaces; `Object.keys(tools.<namespace>)` lists its tools; `for...in` works on both.",
         ...(complete
           ? []
-          : [
-              '- Browse one namespace: `await tools.$codemode.search({ query: "", namespace: "<name>" })`.',
-              "- If search returns `next`, repeat the same search with `offset: next.offset`.",
-            ]),
+          : ['- Browse one namespace: `await tools.$codemode.search({ query: "", namespace: "<name>" })`.']),
       ]
 
-  const language = [
+  const syntax = [
     "",
-    "## Language",
+    "## Syntax",
     "",
-    "Use common JavaScript data operations, functions, control flow, selected standard-library methods, and awaited tool calls. Built-ins include Date, RegExp, Map, Set, URL, URLSearchParams, and URI encoding helpers.",
-    "Modules/imports, classes, generators, timers, fetch, eval, prototype access, unlisted methods, and promise chaining are unavailable. Use Code Mode tools for external operations. Use await with try/catch.",
-    "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
+    "Standard modern JavaScript works: functions/closures, destructuring, template literals, loops, try/catch, spread, optional chaining, the usual Array/String/Object/Math/JSON methods, plus Date, RegExp, Map, Set, and Promise.all/allSettled/race/resolve/reject.",
+    "TypeScript type annotations are allowed and stripped before execution (decorators are not supported).",
+    "Not supported (each fails with a message naming the alternative): classes, generators, for await...of, .then/.catch/.finally (use await with try/catch).",
+    "Dates serialize to ISO strings at data boundaries; Map/Set/RegExp serialize to `{}`.",
   ]
 
   const toolSection: Array<string> = [""]
@@ -635,11 +546,11 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
       for (const tool of group) if (picked.has(tool)) toolSection.push(catalogLine(tool))
     }
     if (!complete) {
-      toolSection.push("", "Search returns complete callable signatures:", `- ${searchDescription.signature}`)
+      toolSection.push("", "Search returns complete callable signatures:", `- ${searchSignature}`)
     }
   }
 
-  const lines = [...intro, ...workflow, ...rules, ...language, ...toolSection]
+  const lines = [...intro, ...workflow, ...rules, ...syntax, ...toolSection]
   return {
     catalog: described,
     instructions: lines.join("\n"),
@@ -648,13 +559,20 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
 }
 
 /**
- * The enumerable names at one node of the callable tool tree - namespace names at the root,
+ * The enumerable names at one node of the host tool tree - namespace names at the root,
  * tool/namespace names below - powering `Object.keys(tools)` and `for...in` over tool
  * references. A callable tool is a leaf and enumerates as `[]` (like `Object.keys` of a
  * function in JS). An unknown path is an `UnknownTool` error pointing at the working
  * discovery idioms, mirroring how calling an unknown tool fails.
  */
-const namespaceKeys = <R>(tools: HostTools<R>, path: ReadonlyArray<string>): ReadonlyArray<string> => {
+const namespaceKeys = <R>(
+  tools: HostTools<R>,
+  path: ReadonlyArray<string>,
+  searchEnabled: boolean,
+): ReadonlyArray<string> => {
+  // The reserved discovery namespace is virtual (never present in the host tree); enumerate
+  // it explicitly so `Object.keys(tools.$codemode)` matches the callable surface.
+  if (searchEnabled && path.length === 1 && path[0] === reservedNamespace) return ["search"]
   let value: HostTool<R> | Definition<R> | HostTools<R> = tools
   for (const segment of path) {
     if (
@@ -663,9 +581,15 @@ const namespaceKeys = <R>(tools: HostTools<R>, path: ReadonlyArray<string>): Rea
       isDefinition(value) ||
       !Object.hasOwn(value, segment)
     ) {
-      throw new ToolRuntimeError("UnknownTool", `Unknown tool namespace '${path.join(".")}'.`, [
-        "Object.keys(tools) lists the available namespaces; tools.$codemode.search({ query }) finds described tools.",
-      ])
+      throw new ToolRuntimeError(
+        "UnknownTool",
+        `Unknown tool namespace '${path.join(".")}'.`,
+        searchEnabled
+          ? [
+              "Object.keys(tools) lists the available namespaces; tools.$codemode.search({ query }) finds described tools.",
+            ]
+          : ["Object.keys(tools) lists the available namespaces."],
+      )
     }
     value = value[segment] as HostTool<R> | Definition<R> | HostTools<R>
   }
@@ -673,7 +597,11 @@ const namespaceKeys = <R>(tools: HostTools<R>, path: ReadonlyArray<string>): Rea
   return Object.keys(value)
 }
 
-const resolve = <R>(tools: HostTools<R>, path: ReadonlyArray<string>): HostTool<R> | Definition<R> => {
+const resolve = <R>(
+  tools: HostTools<R>,
+  path: ReadonlyArray<string>,
+  searchEnabled: boolean,
+): HostTool<R> | Definition<R> => {
   let value: HostTool<R> | Definition<R> | HostTools<R> = tools
 
   for (const segment of path) {
@@ -683,9 +611,11 @@ const resolve = <R>(tools: HostTools<R>, path: ReadonlyArray<string>): HostTool<
       isDefinition(value) ||
       !Object.hasOwn(value, segment)
     ) {
-      throw new ToolRuntimeError("UnknownTool", `Unknown tool '${path.join(".")}'.`, [
-        "Use tools.$codemode.search({ query }) to find available described tools.",
-      ])
+      throw new ToolRuntimeError(
+        "UnknownTool",
+        `Unknown tool '${path.join(".")}'.`,
+        searchEnabled ? ["Use tools.$codemode.search({ query }) to find available described tools."] : [],
+      )
     }
     value = value[segment] as HostTool<R> | Definition<R> | HostTools<R>
   }
@@ -701,22 +631,22 @@ export type ToolRuntime<R = never> = {
   readonly root: ToolReference
   readonly calls: Array<ToolCall>
   readonly invoke: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
-  /** Enumerable namespace/tool names at one node of the callable tool tree; see `namespaceKeys`. */
+  /** Enumerable namespace/tool names at one node of the host tool tree; see `namespaceKeys`. */
   readonly keys: (path: ReadonlyArray<string>) => ReadonlyArray<string>
 }
 
+const failureMessage = (error: unknown): string =>
+  error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed"
+
 export const make = <R>(
   tools: HostTools<R>,
   /** Undefined means unlimited tool calls. */
   maxToolCalls: number | undefined,
-  searchIndex: ReadonlyArray<SearchEntry>,
   hooks?: ToolCallHooks<R>,
+  searchIndex?: ReadonlyArray<SearchEntry>,
 ): ToolRuntime<R> => {
   const calls: Array<ToolCall> = []
-  const callableTools = {
-    ...tools,
-    [reservedNamespace]: { search: makeSearchTool(searchIndex) },
-  }
+  const searchEnabled = searchIndex !== undefined
 
   // Wraps the settling portion of a tool call so onToolCallEnd observes success and failure
   // symmetrically. Interruption (e.g. the execution timeout) fires neither outcome.
@@ -726,16 +656,9 @@ export const make = <R>(
     const startedAt = Date.now()
     return effect.pipe(
       Effect.tap(() => onEnd({ ...call, durationMs: Date.now() - startedAt, outcome: "success" })),
-      Effect.tapError((error) => {
-        const message =
-          error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed"
-        return onEnd({
-          ...call,
-          durationMs: Date.now() - startedAt,
-          outcome: "failure",
-          message,
-        })
-      }),
+      Effect.tapError((error) =>
+        onEnd({ ...call, durationMs: Date.now() - startedAt, outcome: "failure", message: failureMessage(error) }),
+      ),
     )
   }
 
@@ -755,7 +678,7 @@ export const make = <R>(
   return {
     root: new ToolReference([]),
     calls,
-    keys: (path) => namespaceKeys(callableTools, path),
+    keys: (path) => namespaceKeys(tools, path, searchEnabled),
     invoke: (path, args) =>
       Effect.gen(function* () {
         const name = path.join(".")
@@ -766,7 +689,107 @@ export const make = <R>(
             recordCall(call)
             return calls.length - 1
           }).pipe(Effect.tap((index) => hooks?.onToolCallStart?.({ index, name, input }) ?? Effect.void))
-        const tool = resolve(callableTools, path)
+        if (name === "$codemode.search") {
+          if (!searchEnabled) throw new ToolRuntimeError("UnknownTool", `Unknown tool '${name}'.`)
+          const input = externalArgs[0]
+          if (externalArgs.length !== 1 || input === null || typeof input !== "object" || Array.isArray(input)) {
+            throw new ToolRuntimeError(
+              "InvalidToolInput",
+              "tools.$codemode.search expects { query?: string; namespace?: string; limit?: number }.",
+            )
+          }
+          const request = input as { query?: unknown; namespace?: unknown; limit?: unknown }
+          if (request.query !== undefined && typeof request.query !== "string") {
+            throw new ToolRuntimeError(
+              "InvalidToolInput",
+              "tools.$codemode.search query must be a string when provided.",
+            )
+          }
+          if (request.namespace !== undefined && typeof request.namespace !== "string") {
+            throw new ToolRuntimeError(
+              "InvalidToolInput",
+              "tools.$codemode.search namespace must be a string when provided.",
+            )
+          }
+          if (
+            request.limit !== undefined &&
+            (typeof request.limit !== "number" || !Number.isSafeInteger(request.limit) || request.limit <= 0)
+          ) {
+            throw new ToolRuntimeError(
+              "InvalidToolInput",
+              "tools.$codemode.search limit must be a positive safe integer when provided.",
+            )
+          }
+          const query = typeof request.query === "string" ? request.query : ""
+          const namespace = typeof request.namespace === "string" ? request.namespace : undefined
+          const index = yield* recordAndObserve(request)
+          return yield* observeEnd(
+            Effect.try({
+              try: () => {
+                const limit = typeof request.limit === "number" ? request.limit : defaultSearchLimit
+                const scoped =
+                  namespace === undefined ? searchIndex : searchIndex.filter((entry) => entry.namespace === namespace)
+                // A query that names one tool path exactly (canonical path or rendered
+                // JavaScript expression) is a lookup, not a search: return that tool alone.
+                const trimmed = query.trim()
+                const pathQuery = trimmed.startsWith("tools.") ? trimmed.slice("tools.".length) : trimmed
+                const exact =
+                  pathQuery === ""
+                    ? undefined
+                    : scoped.find(
+                        (entry) =>
+                          entry.description.path === pathQuery || toolExpression(entry.description.path) === trimmed,
+                      )
+                const terms = tokenize(query).map(termForms)
+                // Additive field-weighted scoring, summed across terms: exact path or path
+                // segment (20) > path substring (8) > description substring (4) > any
+                // searchable text, incl. input parameter names/descriptions (2). Each term
+                // matches a field when any of its forms (the term or a singular variant)
+                // does. An empty query browses everything, alphabetical by path.
+                const ranked =
+                  exact !== undefined
+                    ? [exact]
+                    : scoped
+                        .map((entry) => {
+                          const path = entry.description.path.toLowerCase()
+                          const description = entry.description.description.toLowerCase()
+                          const score = terms.reduce(
+                            (total, forms) =>
+                              total +
+                              (forms.some((form) => path === form || path.endsWith(`.${form}`)) ? 20 : 0) +
+                              (forms.some((form) => path.includes(form)) ? 8 : 0) +
+                              (forms.some((form) => description.includes(form)) ? 4 : 0) +
+                              (forms.some((form) => entry.searchText.includes(form)) ? 2 : 0),
+                            0,
+                          )
+                          return { entry, score }
+                        })
+                        .filter(({ score }) => terms.length === 0 || score > 0)
+                        .sort(
+                          (left, right) =>
+                            right.score - left.score ||
+                            left.entry.description.path.localeCompare(right.entry.description.path),
+                        )
+                        .map(({ entry }) => entry)
+                // Result paths are rendered as JavaScript expressions so each `path` is
+                // directly usable as the call site (`await tools.github.list({ ... })` or
+                // `await tools.ns["dashed-name"]({ ... })`). The signature is the pretty,
+                // JSDoc-annotated form (schema descriptions and constraints ride along as
+                // field comments).
+                const items = ranked.slice(0, limit).map(({ description, signature }) => ({
+                  ...description,
+                  path: toolExpression(description.path),
+                  signature,
+                }))
+                return copyIn({ items, total: ranked.length }, "Result from tool '$codemode.search'")
+              },
+              catch: (cause) => cause,
+            }),
+            { index, name, input: request },
+          )
+        }
+
+        const tool = resolve(tools, path, searchEnabled)
         let describedInput: unknown
         if (isDefinition(tool)) {
           if (externalArgs.length !== 1)

packages/codemode/src/tool-schema.ts

@@ -1,301 +0,0 @@
-import { JsonPointer, Schema } from "effect"
-import type { Definition, JsonSchema, SchemaType } from "./tool.js"
-
-const isEffectSchema = (schema: SchemaType): schema is Schema.Decoder<unknown> & Schema.Top => Schema.isSchema(schema)
-
-const renderLiteral = (value: unknown): string => JSON.stringify(value) ?? "unknown"
-
-/**
- * Bare TypeScript identifier - usable unquoted as an object key (and, in the tool runtime,
- * with dot access as a tool-path segment). Anything else must be quoted/bracketed.
- */
-export const identifierSegment = /^[A-Za-z_$][A-Za-z0-9_$]*$/
-
-/** Renders a property name as a valid TS object key: bare when an identifier, quoted otherwise. */
-const renderKey = (name: string): string => (identifierSegment.test(name) ? name : JSON.stringify(name))
-
-const effectNumberSentinel = (schema: JsonSchema) =>
-  schema.type === "string" &&
-  Array.isArray(schema.enum) &&
-  schema.enum.length === 1 &&
-  (schema.enum[0] === "NaN" || schema.enum[0] === "Infinity" || schema.enum[0] === "-Infinity")
-
-const intersection = (members: ReadonlyArray<string>): string => {
-  const concrete = members.filter((member) => member !== "unknown")
-  if (concrete.length === 0) return "unknown"
-  if (concrete.length === 1) return concrete[0] ?? "unknown"
-  return concrete.map((member) => (member.includes(" | ") ? `(${member})` : member)).join(" & ")
-}
-
-/**
- * Recursion ceiling for schema rendering. Object, array, and union recursion all increment
- * depth, so this bounds every recursion path - pathological or structurally cyclic schemas
- * degrade to `unknown` instead of overflowing the stack (rendering must never throw).
- */
-const MAX_RENDER_DEPTH = 8
-
-type RenderContext = {
-  readonly definitions: Readonly<Record<string, JsonSchema>>
-  /** Indented, JSDoc-annotated multiline rendering (search results); compact single line otherwise. */
-  readonly pretty: boolean
-}
-
-const hasUnresolvedRef = (
-  schema: JsonSchema,
-  definitions: Readonly<Record<string, JsonSchema>>,
-  seen: ReadonlySet<string> = new Set(),
-  visited: ReadonlySet<JsonSchema> = new Set(),
-): boolean => {
-  if (visited.has(schema)) return false
-  const nextVisited = new Set([...visited, schema])
-  if (schema.$ref !== undefined) {
-    const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1]
-    const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment)
-    if (name === undefined || definitions[name] === undefined || seen.has(name)) return true
-    if (hasUnresolvedRef(definitions[name], definitions, new Set([...seen, name]), nextVisited)) return true
-  }
-  return [
-    ...(schema.anyOf ?? []),
-    ...(schema.oneOf ?? []),
-    ...(schema.allOf ?? []),
-    ...Object.values(schema.properties ?? {}),
-    ...(schema.items === undefined ? [] : [schema.items]),
-    ...(typeof schema.additionalProperties === "object" ? [schema.additionalProperties] : []),
-  ].some((item) => hasUnresolvedRef(item, definitions, seen, nextVisited))
-}
-
-/**
- * Schema constraints a TypeScript type cannot express natively but a model benefits from,
- * surfaced as JSDoc tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`).
- */
-const docTags = (schema: JsonSchema): Array<string> => {
-  const tags: Array<string> = []
-  if (schema.deprecated === true) tags.push("@deprecated")
-  if (schema.default !== undefined) {
-    try {
-      const rendered = JSON.stringify(schema.default)
-      if (rendered !== undefined) tags.push(`@default ${rendered}`)
-    } catch {
-      // unserializable default: skip rather than emit a broken tag
-    }
-  }
-  if (typeof schema.format === "string") tags.push(`@format ${schema.format}`)
-  if (typeof schema.minItems === "number") tags.push(`@minItems ${schema.minItems}`)
-  if (typeof schema.maxItems === "number") tags.push(`@maxItems ${schema.maxItems}`)
-  return tags
-}
-
-/**
- * Format a schema `description` plus `tags` as a JSDoc comment at the given indent,
- * preserving multi-line text (a single line stays `/** ... *\/`; multiple lines become a
- * `*`-prefixed block). `*\/` is neutralized so nothing can close the comment early, and
- * blank leading/trailing lines are trimmed. Returns "" (else a trailing newline) so
- * callers can prepend it directly to the field line.
- */
-const jsdoc = (description: string | undefined, tags: ReadonlyArray<string>, pad: string): string => {
-  const lines = [...(description === undefined ? [] : description.split("\n")), ...tags].map((line) =>
-    line.replaceAll("*/", "* /").replace(/\s+$/, ""),
-  )
-  while (lines.length > 0 && lines[0]!.trim() === "") lines.shift()
-  while (lines.length > 0 && lines[lines.length - 1]!.trim() === "") lines.pop()
-  if (lines.length === 0) return ""
-  if (lines.length === 1) return `${pad}/** ${lines[0]} */\n`
-  const body = lines.map((line) => `${pad} *${line === "" ? "" : ` ${line}`}`).join("\n")
-  return `${pad}/**\n${body}\n${pad} */\n`
-}
-
-const renderSchema = (
-  schema: JsonSchema,
-  ctx: RenderContext,
-  depth = 0,
-  seen: ReadonlySet<string> = new Set(),
-): string => {
-  if (depth > MAX_RENDER_DEPTH) return "unknown"
-  const nested =
-    schema.definitions === undefined && schema.$defs === undefined
-      ? ctx
-      : { ...ctx, definitions: { ...ctx.definitions, ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) } }
-  if (schema.$ref) {
-    const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1]
-    const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment)
-    if (!name || !nested.definitions[name] || seen.has(name)) return "unknown"
-    return intersection([
-      renderSchema(nested.definitions[name], nested, depth, new Set([...seen, name])),
-      renderSchema({ ...schema, $ref: undefined }, nested, depth + 1, seen),
-    ])
-  }
-  if (schema.const !== undefined) return renderLiteral(schema.const)
-  if (schema.enum) return schema.enum.map(renderLiteral).join(" | ")
-  const alternatives = schema.anyOf ?? schema.oneOf
-  if (alternatives) {
-    // Effect's number schema emits `anyOf: [{ type: "number" }, { const: "NaN" },
-    // { const: "Infinity" }, { const: "-Infinity" }]`. Collapse only that artifact;
-    // real JSON Schema unions such as `string | number` or `number | null` must keep
-    // every branch.
-    if (
-      alternatives.some((item) => item.type === "number") &&
-      alternatives.every((item) => item.type === "number" || effectNumberSentinel(item))
-    )
-      return "number"
-    // An empty Schema.Struct({}) emits `anyOf: [{ type: "object" }, { type: "array" }]`
-    // (no properties/items); render the bare shape as {} instead of `{} | Array<unknown>`.
-    if (
-      alternatives.length === 2 &&
-      alternatives[0]?.type === "object" &&
-      alternatives[0].properties === undefined &&
-      alternatives[1]?.type === "array" &&
-      alternatives[1].items === undefined
-    ) {
-      return "{}"
-    }
-    const members = alternatives.map((item) => renderSchema(item, nested, depth + 1, seen))
-    if (members.some((member) => member === "unknown")) return "unknown"
-    return intersection([
-      members.join(" | "),
-      renderSchema({ ...schema, anyOf: undefined, oneOf: undefined }, nested, depth + 1, seen),
-    ])
-  }
-  if (schema.allOf) {
-    const members = schema.allOf.map((item) => renderSchema(item, nested, depth + 1, seen))
-    if (schema.allOf.some((item) => hasUnresolvedRef(item, nested.definitions))) return "unknown"
-    return intersection([renderSchema({ ...schema, allOf: undefined }, nested, depth + 1, seen), ...members])
-  }
-  if (Array.isArray(schema.type)) {
-    return schema.type.map((item) => renderSchema({ ...schema, type: item }, nested, depth + 1, seen)).join(" | ")
-  }
-  if (schema.type === "string") return "string"
-  if (schema.type === "number" || schema.type === "integer") return "number"
-  if (schema.type === "boolean") return "boolean"
-  if (schema.type === "null") return "null"
-  if (schema.type === "array") return `Array<${renderSchema(schema.items ?? {}, nested, depth + 1, seen)}>`
-  if (schema.type === "object" || schema.properties) {
-    const required = new Set(schema.required ?? [])
-    const properties = Object.entries(schema.properties ?? {})
-    const additional = schema.additionalProperties
-    const indexType =
-      additional && typeof additional === "object" ? renderSchema(additional, nested, depth + 1, seen) : undefined
-    const field = ([name, value]: readonly [string, JsonSchema]) =>
-      `${renderKey(name)}${required.has(name) ? "" : "?"}: ${renderSchema(value, nested, depth + 1, seen)}`
-
-    if (!ctx.pretty) {
-      const fields = properties.map(field)
-      if (indexType !== undefined) fields.push(`[key: string]: ${indexType}`)
-      return fields.length === 0 ? "{}" : `{ ${fields.join("; ")} }`
-    }
-
-    // Pretty: an indented block, each described field preceded by its JSDoc comment.
-    if (properties.length === 0 && indexType === undefined) return "{}"
-    const pad = "  ".repeat(depth + 1)
-    const lines = properties.map(
-      (entry) => `${jsdoc(entry[1].description, docTags(entry[1]), pad)}${pad}${field(entry)},`,
-    )
-    if (indexType !== undefined) lines.push(`${pad}[key: string]: ${indexType},`)
-    return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`
-  }
-  return "unknown"
-}
-
-export const toTypeScript = (schema: Schema.Top, decoded = false, pretty = false): string => {
-  try {
-    const visible = decoded ? Schema.toType(schema) : schema
-    const document = Schema.toJsonSchemaDocument(visible) as {
-      readonly schema: JsonSchema
-      readonly definitions?: Readonly<Record<string, JsonSchema>>
-    }
-    return renderSchema(document.schema, { definitions: document.definitions ?? {}, pretty })
-  } catch {
-    return "unknown"
-  }
-}
-
-/** Renders a raw JSON Schema document as a TypeScript type string. */
-export const jsonSchemaToTypeScript = (schema: JsonSchema, pretty = false): string => {
-  try {
-    return renderSchema(schema, { definitions: { ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) }, pretty })
-  } catch {
-    return "unknown"
-  }
-}
-
-/** One input property of a tool, extracted best-effort from its input schema. */
-export type InputProperty = {
-  readonly name: string
-  readonly description: string | undefined
-  readonly required: boolean
-}
-
-/**
- * The property names, descriptions, and required flags of a tool's input schema - the raw
- * material for search text. Best-effort: Effect Schemas go through their
- * JSON Schema document (the same emission signature rendering uses); JSON Schemas are read
- * directly, resolving a trivial top-level `$ref` into `$defs`/`definitions` when present.
- * Anything unresolvable yields `[]` (search falls back to path + description).
- */
-export const inputProperties = <R>(definition: Definition<R>): Array<InputProperty> => {
-  try {
-    const document = isEffectSchema(definition.input)
-      ? (Schema.toJsonSchemaDocument(definition.input) as {
-          readonly schema: JsonSchema
-          readonly definitions?: Readonly<Record<string, JsonSchema>>
-        })
-      : {
-          schema: definition.input,
-          definitions: { ...(definition.input.definitions ?? {}), ...(definition.input.$defs ?? {}) },
-        }
-    const definitions = document.definitions ?? {}
-    let schema = document.schema
-    if (schema.$ref !== undefined) {
-      const segment = schema.$ref.match(/^#\/(?:\$defs|definitions)\/([^/]+)$/)?.[1]
-      const name = segment === undefined ? undefined : JsonPointer.unescapeToken(segment)
-      const resolved = name === undefined ? undefined : definitions[name]
-      if (resolved === undefined) return []
-      schema = resolved
-    }
-    const required = new Set(schema.required ?? [])
-    return Object.entries(schema.properties ?? {}).map(([name, value]) => ({
-      name,
-      description: typeof value.description === "string" ? value.description : undefined,
-      required: required.has(name),
-    }))
-  } catch {
-    return []
-  }
-}
-
-/**
- * The model-visible TypeScript type of a tool's input. `pretty` renders an indented
- * multiline block with schema descriptions and constraints as JSDoc comments on the
- * fields; the default stays the compact single-line form.
- */
-export const inputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
-  isEffectSchema(definition.input)
-    ? toTypeScript(definition.input, false, pretty)
-    : jsonSchemaToTypeScript(definition.input, pretty)
-
-/**
- * The model-visible TypeScript type of a tool's result; tools without an output schema
- * return `unknown`. `pretty` renders the JSDoc-annotated multiline form, as for inputs.
- */
-export const outputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
-  definition.output === undefined
-    ? "unknown"
-    : isEffectSchema(definition.output)
-      ? toTypeScript(definition.output, true, pretty)
-      : jsonSchemaToTypeScript(definition.output, pretty)
-
-/**
- * Decodes tool input before `run` is invoked. Effect Schemas validate (throwing on failure);
- * JSON-Schema-described inputs pass through unvalidated (render-only).
- */
-export const decodeInput = <R>(definition: Definition<R>, value: unknown): unknown =>
-  isEffectSchema(definition.input) ? Schema.decodeUnknownSync(definition.input)(value) : value
-
-/**
- * Decodes a tool result before it is exposed to the program. Effect Schemas validate and
- * transform (throwing on failure); JSON Schema outputs and tools without an output schema pass
- * the host value through unchanged.
- */
-export const decodeOutput = <R>(definition: Definition<R>, value: unknown): unknown =>
-  definition.output !== undefined && isEffectSchema(definition.output)
-    ? Schema.decodeUnknownSync(definition.output)(value)
-    : value

packages/codemode/src/tool.ts

@@ -13,7 +13,6 @@ export type JsonSchema = {
   readonly const?: unknown
   readonly anyOf?: ReadonlyArray<JsonSchema>
   readonly oneOf?: ReadonlyArray<JsonSchema>
-  readonly allOf?: ReadonlyArray<JsonSchema>
   readonly properties?: Readonly<Record<string, JsonSchema>>
   readonly required?: ReadonlyArray<string>
   readonly items?: JsonSchema
@@ -30,25 +29,25 @@ export type JsonSchema = {
 }
 
 /** Either a validating Effect Schema or a render-only JSON Schema document. */
-export type SchemaType = Schema.Decoder<unknown> | JsonSchema
+export type ToolSchema = Schema.Decoder<unknown> | JsonSchema
 
 /** Schema-backed tool definition consumed by a CodeMode tool tree. */
 export type Definition<R = never> = {
   readonly _tag: "CodeModeTool"
   readonly description: string
-  readonly input: SchemaType
-  readonly output: SchemaType | undefined
+  readonly input: ToolSchema
+  readonly output: ToolSchema | undefined
   readonly run: (input: unknown) => Effect.Effect<unknown, unknown, R>
 }
 
 /** The value `run` receives: the decoded type for Effect Schemas, `unknown` for JSON Schemas. */
-type InputType<S> = S extends Schema.Decoder<unknown> ? S["Type"] : unknown
+export type InputType<S> = S extends Schema.Decoder<unknown> ? S["Type"] : unknown
 
 /** The value `run` returns: the encoded type for Effect Schemas, `unknown` otherwise. */
-type ResultType<S> = S extends Schema.Decoder<unknown> ? S["Encoded"] : unknown
+export type ResultType<S> = S extends Schema.Decoder<unknown> ? S["Encoded"] : unknown
 
 /** Options for defining one CodeMode tool. */
-export type Options<I extends SchemaType, O extends SchemaType | undefined, R = never> = {
+export type Options<I extends ToolSchema, O extends ToolSchema | undefined, R = never> = {
   readonly description: string
   readonly input: I
   readonly output?: O
@@ -58,6 +57,256 @@ export type Options<I extends SchemaType, O extends SchemaType | undefined, R =
 export const isDefinition = <R = never>(value: unknown): value is Definition<R> =>
   typeof value === "object" && value !== null && "_tag" in value && value._tag === "CodeModeTool"
 
+const isEffectSchema = (schema: ToolSchema): schema is Schema.Decoder<unknown> & Schema.Top => Schema.isSchema(schema)
+
+const renderLiteral = (value: unknown): string => JSON.stringify(value) ?? "unknown"
+
+/**
+ * Bare TypeScript identifier - usable unquoted as an object key (and, in the tool runtime,
+ * with dot access as a tool-path segment). Anything else must be quoted/bracketed.
+ */
+export const identifierSegment = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+
+/** Renders a property name as a valid TS object key: bare when an identifier, quoted otherwise. */
+const renderKey = (name: string): string => (identifierSegment.test(name) ? name : JSON.stringify(name))
+
+const effectNumberSentinel = (schema: JsonSchema) =>
+  schema.type === "string" &&
+  Array.isArray(schema.enum) &&
+  schema.enum.length === 1 &&
+  (schema.enum[0] === "NaN" || schema.enum[0] === "Infinity" || schema.enum[0] === "-Infinity")
+
+/**
+ * Recursion ceiling for schema rendering. Object, array, and union recursion all increment
+ * depth, so this bounds every recursion path - pathological or structurally cyclic schemas
+ * degrade to `unknown` instead of overflowing the stack (rendering must never throw).
+ */
+const MAX_RENDER_DEPTH = 8
+
+type RenderContext = {
+  readonly definitions: Readonly<Record<string, JsonSchema>>
+  /** Indented, JSDoc-annotated multiline rendering (search results); compact single line otherwise. */
+  readonly pretty: boolean
+}
+
+/**
+ * Schema constraints a TypeScript type cannot express natively but a model benefits from,
+ * surfaced as JSDoc tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`).
+ */
+const docTags = (schema: JsonSchema): Array<string> => {
+  const tags: Array<string> = []
+  if (schema.deprecated === true) tags.push("@deprecated")
+  if (schema.default !== undefined) {
+    try {
+      const rendered = JSON.stringify(schema.default)
+      if (rendered !== undefined) tags.push(`@default ${rendered}`)
+    } catch {
+      // unserializable default: skip rather than emit a broken tag
+    }
+  }
+  if (typeof schema.format === "string") tags.push(`@format ${schema.format}`)
+  if (typeof schema.minItems === "number") tags.push(`@minItems ${schema.minItems}`)
+  if (typeof schema.maxItems === "number") tags.push(`@maxItems ${schema.maxItems}`)
+  return tags
+}
+
+/**
+ * Format a schema `description` plus `tags` as a JSDoc comment at the given indent,
+ * preserving multi-line text (a single line stays `/** ... *\/`; multiple lines become a
+ * `*`-prefixed block). `*\/` is neutralized so nothing can close the comment early, and
+ * blank leading/trailing lines are trimmed. Returns "" (else a trailing newline) so
+ * callers can prepend it directly to the field line.
+ */
+const jsdoc = (description: string | undefined, tags: ReadonlyArray<string>, pad: string): string => {
+  const lines = [...(description === undefined ? [] : description.split("\n")), ...tags].map((line) =>
+    line.replaceAll("*/", "* /").replace(/\s+$/, ""),
+  )
+  while (lines.length > 0 && lines[0]!.trim() === "") lines.shift()
+  while (lines.length > 0 && lines[lines.length - 1]!.trim() === "") lines.pop()
+  if (lines.length === 0) return ""
+  if (lines.length === 1) return `${pad}/** ${lines[0]} */\n`
+  const body = lines.map((line) => `${pad} *${line === "" ? "" : ` ${line}`}`).join("\n")
+  return `${pad}/**\n${body}\n${pad} */\n`
+}
+
+const renderSchema = (
+  schema: JsonSchema,
+  ctx: RenderContext,
+  depth = 0,
+  seen: ReadonlySet<string> = new Set(),
+): string => {
+  if (depth > MAX_RENDER_DEPTH) return "unknown"
+  if (schema.$ref) {
+    const name = schema.$ref.split("/").pop()
+    if (!name || !ctx.definitions[name]) return name ?? "unknown"
+    if (seen.has(name)) return name // recursive type: reference by name rather than loop
+    return renderSchema(ctx.definitions[name], ctx, depth, new Set([...seen, name]))
+  }
+  if (schema.const !== undefined) return renderLiteral(schema.const)
+  if (schema.enum) return schema.enum.map(renderLiteral).join(" | ")
+  const alternatives = schema.anyOf ?? schema.oneOf
+  if (alternatives) {
+    // Effect's number schema emits `anyOf: [{ type: "number" }, { const: "NaN" },
+    // { const: "Infinity" }, { const: "-Infinity" }]`. Collapse only that artifact;
+    // real JSON Schema unions such as `string | number` or `number | null` must keep
+    // every branch.
+    if (
+      alternatives.some((item) => item.type === "number") &&
+      alternatives.every((item) => item.type === "number" || effectNumberSentinel(item))
+    )
+      return "number"
+    // An empty Schema.Struct({}) emits `anyOf: [{ type: "object" }, { type: "array" }]`
+    // (no properties/items); render the bare shape as {} instead of `{} | Array<unknown>`.
+    if (
+      alternatives.length === 2 &&
+      alternatives[0]?.type === "object" &&
+      alternatives[0].properties === undefined &&
+      alternatives[1]?.type === "array" &&
+      alternatives[1].items === undefined
+    ) {
+      return "{}"
+    }
+    return alternatives.map((item) => renderSchema(item, ctx, depth + 1, seen)).join(" | ")
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.map((item) => renderSchema({ type: item }, ctx, depth + 1, seen)).join(" | ")
+  }
+  if (schema.type === "string") return "string"
+  if (schema.type === "number" || schema.type === "integer") return "number"
+  if (schema.type === "boolean") return "boolean"
+  if (schema.type === "null") return "null"
+  if (schema.type === "array") return `Array<${renderSchema(schema.items ?? {}, ctx, depth + 1, seen)}>`
+  if (schema.type === "object" || schema.properties) {
+    const required = new Set(schema.required ?? [])
+    const properties = Object.entries(schema.properties ?? {})
+    const additional = schema.additionalProperties
+    const indexType =
+      additional && typeof additional === "object" ? renderSchema(additional, ctx, depth + 1, seen) : undefined
+    const field = ([name, value]: readonly [string, JsonSchema]) =>
+      `${renderKey(name)}${required.has(name) ? "" : "?"}: ${renderSchema(value, ctx, depth + 1, seen)}`
+
+    if (!ctx.pretty) {
+      const fields = properties.map(field)
+      if (indexType !== undefined) fields.push(`[key: string]: ${indexType}`)
+      return fields.length === 0 ? "{}" : `{ ${fields.join("; ")} }`
+    }
+
+    // Pretty: an indented block, each described field preceded by its JSDoc comment.
+    if (properties.length === 0 && indexType === undefined) return "{}"
+    const pad = "  ".repeat(depth + 1)
+    const lines = properties.map(
+      (entry) => `${jsdoc(entry[1].description, docTags(entry[1]), pad)}${pad}${field(entry)}`,
+    )
+    if (indexType !== undefined) lines.push(`${pad}[key: string]: ${indexType}`)
+    return `{\n${lines.join("\n")}\n${"  ".repeat(depth)}}`
+  }
+  return "unknown"
+}
+
+export const toTypeScript = (schema: Schema.Top, decoded = false, pretty = false): string => {
+  try {
+    const visible = decoded ? Schema.toType(schema) : schema
+    const document = Schema.toJsonSchemaDocument(visible) as {
+      readonly schema: JsonSchema
+      readonly definitions?: Readonly<Record<string, JsonSchema>>
+    }
+    return renderSchema(document.schema, { definitions: document.definitions ?? {}, pretty })
+  } catch {
+    return "unknown"
+  }
+}
+
+/** Renders a raw JSON Schema document as a TypeScript type string. */
+export const jsonSchemaToTypeScript = (schema: JsonSchema, pretty = false): string => {
+  try {
+    return renderSchema(schema, { definitions: { ...(schema.definitions ?? {}), ...(schema.$defs ?? {}) }, pretty })
+  } catch {
+    return "unknown"
+  }
+}
+
+/** One input property of a tool, extracted best-effort from its input schema. */
+export type InputProperty = {
+  readonly name: string
+  readonly description: string | undefined
+  readonly required: boolean
+}
+
+/**
+ * The property names, descriptions, and required flags of a tool's input schema - the raw
+ * material for search text. Best-effort: Effect Schemas go through their
+ * JSON Schema document (the same emission signature rendering uses); JSON Schemas are read
+ * directly, resolving a trivial top-level `$ref` into `$defs`/`definitions` when present.
+ * Anything unresolvable yields `[]` (search falls back to path + description).
+ */
+export const inputProperties = <R>(definition: Definition<R>): Array<InputProperty> => {
+  try {
+    const document = isEffectSchema(definition.input)
+      ? (Schema.toJsonSchemaDocument(definition.input) as {
+          readonly schema: JsonSchema
+          readonly definitions?: Readonly<Record<string, JsonSchema>>
+        })
+      : {
+          schema: definition.input,
+          definitions: { ...(definition.input.definitions ?? {}), ...(definition.input.$defs ?? {}) },
+        }
+    const definitions = document.definitions ?? {}
+    let schema = document.schema
+    if (schema.$ref !== undefined) {
+      const name = schema.$ref.split("/").pop()
+      const resolved = name === undefined ? undefined : definitions[name]
+      if (resolved === undefined) return []
+      schema = resolved
+    }
+    const required = new Set(schema.required ?? [])
+    return Object.entries(schema.properties ?? {}).map(([name, value]) => ({
+      name,
+      description: typeof value.description === "string" ? value.description : undefined,
+      required: required.has(name),
+    }))
+  } catch {
+    return []
+  }
+}
+
+/**
+ * The model-visible TypeScript type of a tool's input. `pretty` renders an indented
+ * multiline block with schema descriptions and constraints as JSDoc comments on the
+ * fields; the default stays the compact single-line form.
+ */
+export const inputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
+  isEffectSchema(definition.input)
+    ? toTypeScript(definition.input, false, pretty)
+    : jsonSchemaToTypeScript(definition.input, pretty)
+
+/**
+ * The model-visible TypeScript type of a tool's result; tools without an output schema
+ * return `unknown`. `pretty` renders the JSDoc-annotated multiline form, as for inputs.
+ */
+export const outputTypeScript = <R>(definition: Definition<R>, pretty = false): string =>
+  definition.output === undefined
+    ? "unknown"
+    : isEffectSchema(definition.output)
+      ? toTypeScript(definition.output, true, pretty)
+      : jsonSchemaToTypeScript(definition.output, pretty)
+
+/**
+ * Decodes tool input before `run` is invoked. Effect Schemas validate (throwing on failure);
+ * JSON-Schema-described inputs pass through unvalidated (render-only).
+ */
+export const decodeInput = <R>(definition: Definition<R>, value: unknown): unknown =>
+  isEffectSchema(definition.input) ? Schema.decodeUnknownSync(definition.input)(value) : value
+
+/**
+ * Decodes a tool result before it is exposed to the program. Effect Schemas validate and
+ * transform (throwing on failure); JSON Schema outputs and tools without an output schema pass
+ * the host value through unchanged.
+ */
+export const decodeOutput = <R>(definition: Definition<R>, value: unknown): unknown =>
+  definition.output !== undefined && isEffectSchema(definition.output)
+    ? Schema.decodeUnknownSync(definition.output)(value)
+    : value
+
 /**
  * Defines one schema-described tool available to a CodeMode program through `tools.*`.
  *
@@ -85,7 +334,7 @@ export const isDefinition = <R = never>(value: unknown): value is Definition<R>
  * })
  * ```
  */
-export const make = <I extends SchemaType, const O extends SchemaType | undefined = undefined, R = never>(
+export const make = <I extends ToolSchema, const O extends ToolSchema | undefined = undefined, R = never>(
   options: Options<I, O, R>,
 ): Definition<R> => ({
   _tag: "CodeModeTool",
@@ -94,3 +343,6 @@ export const make = <I extends SchemaType, const O extends SchemaType | undefine
   output: options.output,
   run: (input) => options.run(input as InputType<I>),
 })
+
+/** Constructors for schema-backed tools exposed inside CodeMode programs. */
+export const Tool = { make, isDefinition }

packages/codemode/src/values.ts

@@ -27,23 +27,8 @@ export class SandboxSet {
   readonly set = new Set<unknown>()
 }
 
-export class SandboxURLSearchParams {
-  constructor(readonly params: URLSearchParams) {}
-}
-
-export class SandboxURL {
-  readonly searchParams: SandboxURLSearchParams
-  constructor(readonly url: URL) {
-    this.searchParams = new SandboxURLSearchParams(url.searchParams)
-  }
-}
-
-export const isSandboxValue = (
-  value: unknown,
-): value is SandboxDate | SandboxRegExp | SandboxMap | SandboxSet | SandboxURL | SandboxURLSearchParams =>
+export const isSandboxValue = (value: unknown): value is SandboxDate | SandboxRegExp | SandboxMap | SandboxSet =>
   value instanceof SandboxDate ||
   value instanceof SandboxRegExp ||
   value instanceof SandboxMap ||
-  value instanceof SandboxSet ||
-  value instanceof SandboxURL ||
-  value instanceof SandboxURLSearchParams
+  value instanceof SandboxSet

packages/codemode/test/codemode.test.ts

@@ -1,8 +1,16 @@
 import { describe, expect, test } from "bun:test"
 import { Cause, Effect, Schema } from "effect"
-import { CodeMode, Tool, toolError } from "../src/index.js"
+import {
+  CodeMode,
+  ExecuteInputSchema,
+  ExecuteResultSchema,
+  Tool,
+  toolError,
+  type ExecutionLimits,
+} from "../src/index.js"
+import type { Definition } from "../src/tool.js"
 
-const run = (tool: Tool.Definition<never>) =>
+const run = (tool: Definition<never>) =>
   Effect.runPromise(CodeMode.make({ tools: { host: { call: tool } } }).execute("return await tools.host.call({})"))
 
 class UnsafeHostError extends Schema.TaggedErrorClass<UnsafeHostError>()("UnsafeHostError", {
@@ -227,7 +235,7 @@ describe("CodeMode console capture", () => {
       logs: ['Thread info: {"name":"Demo","count":2}', "[warn] careful"],
       toolCalls: [],
     })
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
   })
 
   test("keeps logs captured before failures", async () => {
@@ -348,7 +356,7 @@ describe("CodeMode output budget", () => {
   })
 
   test("truncates an oversized result value with a marker instead of failing", async () => {
-    const limits: CodeMode.ExecutionLimits = { maxOutputBytes: 40 }
+    const limits: ExecutionLimits = { maxOutputBytes: 40 }
     const result = await Effect.runPromise(
       CodeMode.execute({
         code: `return { data: "${"x".repeat(200)}" }`,
@@ -363,11 +371,11 @@ describe("CodeMode output budget", () => {
     expect(result.value).toMatch(
       /^\{"data":"x+ \[result truncated: \d+ bytes exceeds the 40-byte output limit; return a smaller value\]$/,
     )
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
   })
 
   test("keeps leading logs within the remaining budget and marks the cut", async () => {
-    const limits: CodeMode.ExecutionLimits = { maxOutputBytes: 40 }
+    const limits: ExecutionLimits = { maxOutputBytes: 40 }
     const result = await Effect.runPromise(
       CodeMode.execute({
         code: `
@@ -426,7 +434,7 @@ describe("CodeMode schema flexibility", () => {
       {
         path: "adapter.call",
         description: "Call an adapter-described tool",
-        signature: "tools.adapter.call(input: {\n  id: string,\n  count?: number,\n}): Promise<unknown>",
+        signature: "tools.adapter.call(input: { id: string; count?: number }): Promise<unknown>",
       },
     ])
 
@@ -459,7 +467,7 @@ describe("CodeMode schema flexibility", () => {
       {
         path: "users.lookup",
         description: "Look up a user",
-        signature: "tools.users.lookup(input: {\n  login: string,\n}): Promise<{\n  login: string,\n  id: number,\n}>",
+        signature: "tools.users.lookup(input: { login: string }): Promise<{ login: string; id: number }>",
       },
     ])
 
@@ -475,7 +483,7 @@ describe("CodeMode schema flexibility", () => {
       run: () => Effect.succeed("pong"),
     })
     const runtime = CodeMode.make({ tools: { net: { ping } } })
-    expect(runtime.catalog()[0]?.signature).toBe("tools.net.ping(input: {\n  host: string,\n}): Promise<unknown>")
+    expect(runtime.catalog()[0]?.signature).toBe("tools.net.ping(input: { host: string }): Promise<unknown>")
 
     const result = await Effect.runPromise(runtime.execute(`return await tools.net.ping({ host: "example.test" })`))
     expect(result.ok).toBe(true)
@@ -493,17 +501,24 @@ describe("CodeMode public contract", () => {
   const tools = { orders: { lookup } }
   const source = `return await tools.orders.lookup({ id: "order_42" })`
 
-  test("keeps one-shot and reusable execution equivalent", async () => {
+  test("keeps one-shot, reusable, and agent-tool execution equivalent", async () => {
     const runtime = CodeMode.make({ tools })
-    const [oneShot, reusable] = await Promise.all([
+    const agentTool = runtime.agentTool()
+    const [oneShot, reusable, projected] = await Promise.all([
       Effect.runPromise(CodeMode.execute({ tools, code: source })),
       Effect.runPromise(runtime.execute(source)),
+      Effect.runPromise(agentTool.execute({ code: source })),
     ])
 
     expect(reusable).toStrictEqual(oneShot)
-    const input: CodeMode.Input = { code: source }
-    expect(Schema.decodeUnknownSync(CodeMode.Input)(input)).toStrictEqual(input)
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(reusable)))).toStrictEqual(reusable)
+    expect(projected).toStrictEqual(oneShot)
+    expect(agentTool.name).toBe("code")
+    expect(agentTool.input).toBe(ExecuteInputSchema)
+    expect(agentTool.output).toBe(ExecuteResultSchema)
+    expect(agentTool.description).toBe(runtime.instructions())
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(projected)))).toStrictEqual(
+      projected,
+    )
   })
 
   test("inlines a COMPLETE small catalog and keeps search registered but unadvertised", async () => {
@@ -512,19 +527,19 @@ describe("CodeMode public contract", () => {
       {
         path: "orders.lookup",
         description: "Look up an order by ID",
-        signature: "tools.orders.lookup(input: {\n  id: string,\n}): Promise<{\n  id: string,\n  status: string,\n}>",
+        signature: "tools.orders.lookup(input: { id: string }): Promise<{ id: string; status: string }>",
       },
     ])
     expect(runtime.instructions()).toContain("Available tools (COMPLETE list")
     expect(runtime.instructions()).toContain("- orders (1 tool)")
     expect(runtime.instructions()).toContain(
-      "  - tools.orders.lookup(input: {\n  id: string,\n}): Promise<{\n  id: string,\n  status: string,\n}> // Look up an order by ID",
+      "  - tools.orders.lookup(input: { id: string }): Promise<{ id: string; status: string }> // Look up an order by ID",
     )
     // A fully inlined catalog does not advertise search in the instructions...
     expect(runtime.instructions()).not.toMatch(/\$codemode/)
 
-    // ...but the search tool stays registered, so a speculative call still works with the
-    // same signature as the inline catalog.
+    // ...but the search tool stays registered, so a speculative call still works. Search
+    // results carry the pretty multiline signature; the inline catalog stays compact.
     const result = await Effect.runPromise(runtime.execute(`return await tools.$codemode.search({ query: "order" })`))
     expect(result.ok).toBe(true)
     if (result.ok) {
@@ -533,12 +548,10 @@ describe("CodeMode public contract", () => {
           {
             path: "tools.orders.lookup",
             description: "Look up an order by ID",
-            signature:
-              "tools.orders.lookup(input: {\n  id: string,\n}): Promise<{\n  id: string,\n  status: string,\n}>",
+            signature: "tools.orders.lookup(input: {\n  id: string\n}): Promise<{\n  id: string\n  status: string\n}>",
           },
         ],
-        remaining: 0,
-        next: null,
+        total: 1,
       })
     }
   })
@@ -556,11 +569,11 @@ describe("CodeMode public contract", () => {
       {
         path: "context7.resolve-library-id",
         description: "Resolve a library ID",
-        signature: 'tools.context7["resolve-library-id"](input: {\n  libraryName: string,\n}): Promise<string>',
+        signature: 'tools.context7["resolve-library-id"](input: { libraryName: string }): Promise<string>',
       },
     ])
     expect(runtime.instructions()).toContain(
-      'tools.context7["resolve-library-id"](input: {\n  libraryName: string,\n}): Promise<string>',
+      'tools.context7["resolve-library-id"](input: { libraryName: string }): Promise<string>',
     )
 
     const search = await Effect.runPromise(
@@ -573,11 +586,10 @@ describe("CodeMode public contract", () => {
           {
             path: 'tools.context7["resolve-library-id"]',
             description: "Resolve a library ID",
-            signature: 'tools.context7["resolve-library-id"](input: {\n  libraryName: string,\n}): Promise<string>',
+            signature: 'tools.context7["resolve-library-id"](input: {\n  libraryName: string\n}): Promise<string>',
           },
         ],
-        remaining: 0,
-        next: null,
+        total: 1,
       })
     }
 
@@ -591,7 +603,7 @@ describe("CodeMode public contract", () => {
       runtime.execute(`return await tools.$codemode.search({ query: 'tools.context7["resolve-library-id"]' })`),
     )
     expect(exact.ok).toBe(true)
-    if (exact.ok) expect(exact.value).toMatchObject({ remaining: 0, next: null })
+    if (exact.ok) expect((exact.value as { total: number }).total).toBe(1)
   })
 
   test("instructions use markdown sections with placeholder-only call forms", () => {
@@ -600,26 +612,23 @@ describe("CodeMode public contract", () => {
     // Sections in order: workflow at the top, catalog at the bottom.
     expect(instructions).toContain("## Workflow")
     expect(instructions).toContain("## Rules")
-    expect(instructions).toContain("## Language")
+    expect(instructions).toContain("## Syntax")
     expect(instructions.indexOf("## Workflow")).toBeLessThan(instructions.indexOf("## Rules"))
-    expect(instructions.indexOf("## Rules")).toBeLessThan(instructions.indexOf("## Language"))
-    expect(instructions.indexOf("## Language")).toBeLessThan(
-      instructions.indexOf("\n## Available tools (COMPLETE list"),
+    expect(instructions.indexOf("## Rules")).toBeLessThan(instructions.indexOf("## Syntax"))
+    expect(instructions.indexOf("## Syntax")).toBeLessThan(instructions.indexOf("\n## Available tools (COMPLETE list"))
+    // The workflow carries the result-shape guidance; Rules only add content beyond it.
+    expect(instructions).toContain(
+      '`const data = typeof res === "string" ? JSON.parse(res) : res` - most tools return JSON as a string',
     )
-    expect(instructions).not.toContain("JSON.parse(res)")
     expect(instructions).toContain("Return only the fields you need")
-    expect(instructions).toContain("avoid returning large raw payloads")
-    expect(instructions).toContain("Do not infer or normalize tool names")
-    expect(instructions).toContain("bracket notation and quotes are part of the path")
-    expect(instructions).toContain("surrounding agent tools are not available")
-    expect(instructions).toContain("Only Code Mode tools listed here and internal runtime tools")
-    // Placeholders use generic namespace/tool/field names only - no fabricated real tools
-    // and no real catalog tools cherry-picked into example lines.
-    expect(instructions).toContain("`const result = await tools.<namespace>.<tool>(input)`")
-    expect(instructions).toContain("Return only the fields you need from structured results")
-    expect(instructions).toContain("check that it is a non-null object and not an array")
-    expect(instructions).not.toContain("result.<field>")
-    expect(instructions).not.toContain("data.<field>")
+    expect(instructions).toContain("raw payloads get truncated and waste context")
+    expect(instructions).toContain("`const res = await tools.<namespace>.<tool>(input)`")
+    expect(instructions).toContain("surrounding agent tools are not available unless listed here")
+    expect(instructions).toContain("Only tools listed here are available inside `tools`")
+    expect(instructions).toContain("bracket notation may appear for names that are not JavaScript identifiers")
+    // Placeholders use the <namespace>.<tool>/<field> style ONLY - no fabricated tool
+    // names, and no real catalog tools cherry-picked into example lines.
+    expect(instructions).toContain("`return { <field>: data.<field> }`")
     expect(instructions).not.toContain("total_count")
     expect(instructions).not.toContain("list_issues")
     expect(instructions).not.toContain("tools.orders.lookup({")
@@ -627,39 +636,38 @@ describe("CodeMode public contract", () => {
     expect(instructions).toContain("1. Pick a tool from the list under `## Available tools`")
     expect(instructions).not.toContain("Browse one namespace")
 
-    const partial = CodeMode.make({ tools, discovery: { catalogBudget: 0 } }).instructions()
+    const partial = CodeMode.make({ tools, discovery: { maxInlineCatalogTokens: 0 } }).instructions()
     // PARTIAL: the workflow starts with search (with query-style guidance that is clearly
     // a query string, never a tool name) and the browse-namespace rule appears.
     expect(partial).toContain(
-      '1. If needed, discover tools: `return await tools.$codemode.search({ query: "<intent + key nouns>" })`.',
+      '1. Find a tool (skip when it is already listed below): `const { items } = await tools.$codemode.search({ query: "<intent + key nouns>" })` - short phrases like "list issues" work best.',
     )
-    expect(partial).toContain("In the next execution, copy a returned path exactly")
     expect(partial).toContain(
-      "Only Code Mode tools listed here or returned by `tools.$codemode.search` and internal runtime tools",
+      "Only tools listed here or returned by `tools.$codemode.search` are available inside `tools`",
     )
     expect(partial).toContain(
       '- Browse one namespace: `await tools.$codemode.search({ query: "", namespace: "<name>" })`.',
     )
-    expect(partial).toContain("repeat the same search with `offset: next.offset`")
-    expect(partial).toContain("  limit?: number,\n  offset?: number,")
     expect(partial).not.toContain("total_count")
     expect(partial).not.toContain("tools.orders.lookup({")
   })
 
-  test("the language section describes the restricted runtime without overclaiming", () => {
+  test("the syntax section names what is unusual or missing, not an allowlist", () => {
     const instructions = CodeMode.make({ tools }).instructions()
-    expect(instructions).toContain("restricted JavaScript language for calling tools")
-    expect(instructions).toContain("not a general-purpose runtime")
-    expect(instructions).not.toContain("Standard modern JavaScript works")
-    expect(instructions).not.toContain("TypeScript type annotations")
-    for (const missing of ["Modules/imports", "classes", "generators", "fetch", "promise chaining"]) {
+    // Models already know JavaScript; the section leads with that.
+    expect(instructions).toContain("Standard modern JavaScript works")
+    expect(instructions).toContain("TypeScript type annotations are allowed and stripped before execution")
+    // The not-supported list is derived from (and verified against) the interpreter.
+    expect(instructions).toContain("Not supported")
+    for (const missing of ["classes", "generators", "for await...of", ".then/.catch/.finally"]) {
       expect(instructions).toContain(missing)
     }
-    expect(instructions).toContain("URL, URLSearchParams, and URI encoding helpers")
-    expect(instructions).not.toContain("host globals")
-    expect(instructions).toContain("Use Code Mode tools for external operations")
+    // Implemented by the DSL-expansion pass, so no longer listed as missing.
+    expect(instructions).not.toContain("instanceof Error")
+    expect(instructions).not.toContain("splice")
+    // The data-boundary note survives.
     expect(instructions).toContain(
-      "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
+      "Dates serialize to ISO strings at data boundaries; Map/Set/RegExp serialize to `{}`.",
     )
   })
 
@@ -667,7 +675,7 @@ describe("CodeMode public contract", () => {
     const runtime = CodeMode.make({})
     const instructions = runtime.instructions()
     expect(instructions).toContain("No tools are currently available.")
-    expect(instructions).toContain("## Language")
+    expect(instructions).toContain("## Syntax")
     expect(instructions).toContain("## Available tools")
     expect(instructions).not.toContain("## Workflow")
     expect(instructions).not.toContain("## Rules")
@@ -689,7 +697,7 @@ describe("CodeMode public contract", () => {
     })
     const runtime = CodeMode.make({
       tools: { thread: { uploadFile: upload, generateImage: generate }, orders: { lookup } },
-      discovery: { catalogBudget: 0 },
+      discovery: { maxInlineCatalogTokens: 0 },
     })
     expect(runtime.instructions()).toContain(
       "Available tools (PARTIAL - 0 of 3 shown; find the rest with tools.$codemode.search)",
@@ -714,16 +722,15 @@ describe("CodeMode public contract", () => {
         {
           path: "tools.thread.uploadFile",
           description: "Upload one readable local file to the current Discord thread",
-          signature: "tools.thread.uploadFile(input: {\n  path: string,\n}): Promise<{\n  sent: boolean,\n}>",
+          signature: "tools.thread.uploadFile(input: {\n  path: string\n}): Promise<{\n  sent: boolean\n}>",
         },
         {
           path: "tools.thread.generateImage",
           description: "Generate an image and upload it to the current Discord thread",
-          signature: "tools.thread.generateImage(input: {\n  prompt: string,\n}): Promise<{\n  sent: boolean,\n}>",
+          signature: "tools.thread.generateImage(input: {\n  prompt: string\n}): Promise<{\n  sent: boolean\n}>",
         },
       ],
-      remaining: 0,
-      next: null,
+      total: 2,
     })
     expect(result.toolCalls).toStrictEqual([{ name: "$codemode.search" }])
 
@@ -769,14 +776,9 @@ describe("CodeMode public contract", () => {
     const browse = await Effect.runPromise(runtime.execute(`return await tools.$codemode.search({})`))
     expect(browse.ok).toBe(true)
     if (browse.ok) {
-      const value = browse.value as {
-        items: Array<{ path: string }>
-        remaining: number
-        next: { offset: number } | null
-      }
+      const value = browse.value as { items: Array<{ path: string }>; total: number }
       expect(value.items).toHaveLength(10)
-      expect(value.remaining).toBe(4)
-      expect(value.next).toStrictEqual({ offset: 10 })
+      expect(value.total).toBe(14)
     }
 
     for (const query of ["many.tool13", "tools.many.tool13"]) {
@@ -790,11 +792,10 @@ describe("CodeMode public contract", () => {
             {
               path: "tools.many.tool13",
               description: "Numbered tool 13",
-              signature: "tools.many.tool13(input: {\n  id: string,\n}): Promise<string>",
+              signature: "tools.many.tool13(input: {\n  id: string\n}): Promise<string>",
             },
           ],
-          remaining: 0,
-          next: null,
+          total: 1,
         })
       }
     }
@@ -821,8 +822,8 @@ describe("CodeMode public contract", () => {
     )
     expect(browse.ok).toBe(true)
     if (browse.ok) {
-      const value = browse.value as { items: Array<{ path: string }>; remaining: number }
-      expect(value.remaining).toBe(0)
+      const value = browse.value as { items: Array<{ path: string }>; total: number }
+      expect(value.total).toBe(2)
       expect(value.items.map((item) => item.path)).toStrictEqual([
         "tools.github.create_issue",
         "tools.github.list_issues",
@@ -835,8 +836,8 @@ describe("CodeMode public contract", () => {
     )
     expect(scoped.ok).toBe(true)
     if (scoped.ok) {
-      const value = scoped.value as { items: Array<{ path: string }>; remaining: number }
-      expect(value.remaining).toBe(0)
+      const value = scoped.value as { items: Array<{ path: string }>; total: number }
+      expect(value.total).toBe(1)
       expect(value.items[0]?.path).toBe("tools.linear.list_issues")
     }
 
@@ -872,8 +873,8 @@ describe("CodeMode public contract", () => {
     )
     expect(byParameter.ok).toBe(true)
     if (byParameter.ok) {
-      const value = byParameter.value as { items: Array<{ path: string }>; remaining: number }
-      expect(value.remaining).toBe(0)
+      const value = byParameter.value as { items: Array<{ path: string }>; total: number }
+      expect(value.total).toBe(1)
       expect(value.items[0]?.path).toBe("tools.files.upload")
     }
 
@@ -883,8 +884,8 @@ describe("CodeMode public contract", () => {
     )
     expect(bySubstring.ok).toBe(true)
     if (bySubstring.ok) {
-      const value = bySubstring.value as { items: Array<{ path: string }>; remaining: number }
-      expect(value.remaining).toBe(0)
+      const value = bySubstring.value as { items: Array<{ path: string }>; total: number }
+      expect(value.total).toBe(1)
       expect(value.items[0]?.path).toBe("tools.files.upload")
     }
   })
@@ -912,8 +913,8 @@ describe("CodeMode public contract", () => {
     )
     expect(plural.ok).toBe(true)
     if (plural.ok) {
-      const value = plural.value as { items: Array<{ path: string }>; remaining: number }
-      expect(value.remaining).toBe(0)
+      const value = plural.value as { items: Array<{ path: string }>; total: number }
+      expect(value.total).toBe(1)
       expect(value.items[0]?.path).toBe("tools.tracker.fetch_all")
     }
 
@@ -921,8 +922,8 @@ describe("CodeMode public contract", () => {
     const ranked = await Effect.runPromise(runtime.execute(`return await tools.$codemode.search({ query: "issues" })`))
     expect(ranked.ok).toBe(true)
     if (ranked.ok) {
-      const value = ranked.value as { items: Array<{ path: string }>; remaining: number }
-      expect(value.remaining).toBe(0)
+      const value = ranked.value as { items: Array<{ path: string }>; total: number }
+      expect(value.total).toBe(2)
       expect(value.items.map((item) => item.path)).toStrictEqual([
         "tools.github.list_issues",
         "tools.tracker.fetch_all",
@@ -948,33 +949,13 @@ describe("CodeMode public contract", () => {
     const browse = await Effect.runPromise(runtime.execute(`return await tools.$codemode.search({})`))
     expect(browse.ok).toBe(true)
     if (browse.ok) {
-      const value = browse.value as { items: Array<{ path: string }>; remaining: number; next: unknown }
+      const value = browse.value as { items: Array<{ path: string }>; total: number }
       expect(value.items.map((item) => item.path)).toStrictEqual([
         "tools.alpha.aardvark",
         "tools.alpha.beta",
         "tools.zeta.last",
       ])
-      expect(value.remaining).toBe(0)
-      expect(value.next).toBeNull()
     }
-
-    const middle = await Effect.runPromise(
-      runtime.execute(`return await tools.$codemode.search({ limit: 1, offset: 1 })`),
-    )
-    expect(middle.ok).toBe(true)
-    if (middle.ok) {
-      expect(middle.value).toMatchObject({
-        items: [{ path: "tools.alpha.beta" }],
-        remaining: 1,
-        next: { offset: 2 },
-      })
-    }
-
-    const exhausted = await Effect.runPromise(
-      runtime.execute(`return await tools.$codemode.search({ limit: 1, offset: 3 })`),
-    )
-    expect(exhausted.ok).toBe(true)
-    if (exhausted.ok) expect(exhausted.value).toStrictEqual({ items: [], remaining: 0, next: null })
   })
 
   test("inlines round-robin across namespaces so one expensive namespace cannot starve the rest", () => {
@@ -999,7 +980,7 @@ describe("CodeMode public contract", () => {
     // other namespaces from inlining (beta already got its line in the same round).
     const runtime = CodeMode.make({
       tools: { alpha: { cheap, expensive }, beta: { cheap } },
-      discovery: { catalogBudget: 40 },
+      discovery: { maxInlineCatalogTokens: 40 },
     })
 
     const instructions = runtime.instructions()
@@ -1007,38 +988,14 @@ describe("CodeMode public contract", () => {
       "Available tools (PARTIAL - 2 of 3 shown; find the rest with tools.$codemode.search)",
     )
     expect(instructions).toContain("- alpha (2 tools, 1 shown)")
-    expect(instructions).toContain("  - tools.alpha.cheap(input: {\n  q: string,\n}): Promise<string> // Cheap")
+    expect(instructions).toContain("  - tools.alpha.cheap(input: { q: string }): Promise<string> // Cheap")
     expect(instructions).not.toContain("tools.alpha.expensive(")
     // Fully shown namespaces read cleanly (no "shown" annotation).
     expect(instructions).toContain("- beta (1 tool)")
-    expect(instructions).toContain("  - tools.beta.cheap(input: {\n  q: string,\n}): Promise<string> // Cheap")
+    expect(instructions).toContain("  - tools.beta.cheap(input: { q: string }): Promise<string> // Cheap")
     expect(instructions).toMatch(/\$codemode\.search/)
   })
 
-  test("charges inline JSDoc against the catalog token budget", () => {
-    const documented = Tool.make({
-      description: "Look up a record",
-      input: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "A detailed identifier description. ".repeat(20) },
-        },
-        required: ["id"],
-      } as const,
-      run: () => Effect.succeed("ok"),
-    })
-    const runtime = CodeMode.make({
-      tools: { records: { lookup: documented } },
-      discovery: { catalogBudget: 40 },
-    })
-
-    expect(runtime.catalog()[0]?.signature).toContain("/** A detailed identifier description.")
-    expect(runtime.instructions()).toContain(
-      "Available tools (PARTIAL - 0 of 1 shown; find the rest with tools.$codemode.search)",
-    )
-    expect(runtime.instructions()).not.toContain("tools.records.lookup(input:")
-  })
-
   test("decodes tool input and output before exposing either side", async () => {
     const observed: Array<unknown> = []
     const transformed = Tool.make({
@@ -1078,7 +1035,7 @@ describe("CodeMode public contract", () => {
       value: { top: null, nested: [1, null] },
       toolCalls: [],
     })
-    expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
+    expect(Schema.decodeUnknownSync(ExecuteResultSchema)(JSON.parse(JSON.stringify(result)))).toStrictEqual(result)
   })
 
   test("rejects invalid configuration and discovery limits", async () => {
@@ -1089,27 +1046,17 @@ describe("CodeMode public contract", () => {
     expect(() => CodeMode.execute({ code: "return 1", limits: { maxToolCalls: -1 } })).toThrow(RangeError)
     expect(() => CodeMode.execute({ code: "return 1", limits: { maxOutputBytes: -1 } })).toThrow(RangeError)
 
-    expect(() => CodeMode.make({ tools, discovery: { catalogBudget: -1 } })).toThrow(RangeError)
+    expect(() => CodeMode.make({ tools, discovery: { maxInlineCatalogTokens: -1 } })).toThrow(RangeError)
 
     const result = await Effect.runPromise(
       CodeMode.make({
         tools,
-        discovery: { catalogBudget: 0 },
+        discovery: { maxInlineCatalogTokens: 0 },
       }).execute(`return await tools.$codemode.search({ query: "order", limit: 0.5 })`),
     )
     expect(result.ok).toBe(false)
     if (result.ok) return
     expect(result.error.kind).toBe("InvalidToolInput")
-
-    for (const offset of [-1, 0.5, Number.MAX_SAFE_INTEGER + 1, "1"]) {
-      const invalidOffset = await Effect.runPromise(
-        CodeMode.make({ tools }).execute(
-          `return await tools.$codemode.search({ query: "order", offset: ${JSON.stringify(offset)} })`,
-        ),
-      )
-      expect(invalidOffset.ok).toBe(false)
-      if (!invalidOffset.ok) expect(invalidOffset.error.kind).toBe("InvalidToolInput")
-    }
   })
 
   test("enforces the tool-call limit as a diagnostic", async () => {

packages/codemode/test/enumeration.test.ts

@@ -41,7 +41,7 @@ describe("Object.keys over tool references", () => {
       const namespaces = Object.keys(tools)
       return { namespaces, count: namespaces.length }
     `),
-    ).toEqual({ namespaces: ["github", "memory", "playwright", "$codemode"], count: 4 })
+    ).toEqual({ namespaces: ["github", "memory", "playwright"], count: 3 })
   })
 
   test("enumerates tool names at a nested namespace", async () => {
@@ -52,7 +52,7 @@ describe("Object.keys over tool references", () => {
     expect(await value(`return Object.keys(tools.github.list_issues)`)).toEqual([])
   })
 
-  test("the internal discovery namespace enumerates its callable surface", async () => {
+  test("the virtual discovery namespace enumerates its callable surface", async () => {
     expect(await value(`return Object.keys(tools.$codemode)`)).toEqual(["search"])
   })
 
@@ -137,7 +137,7 @@ describe("for...in", () => {
     ).toBe("only")
   })
 
-  test("enumerates namespaces and tools from the callable tool tree", async () => {
+  test("enumerates namespaces and tools from the host tool tree", async () => {
     expect(
       await value(`
       const names = []
@@ -146,7 +146,7 @@ describe("for...in", () => {
       }
       return names
     `),
-    ).toEqual(["github.list_issues", "github.get_issue", "memory.search", "playwright.navigate", "$codemode.search"])
+    ).toEqual(["github.list_issues", "github.get_issue", "memory.search", "playwright.navigate"])
   })
 
   test("unsupported values fail with a hint at for...of and Object.keys", async () => {

packages/codemode/test/fixtures/openapi-happy-path.json

@@ -1,245 +0,0 @@
-{
-  "openapi": "3.1.0",
-  "info": {
-    "title": "CodeMode Happy Path",
-    "version": "1.0.0"
-  },
-  "servers": [
-    {
-      "url": "https://api.example.test/v1"
-    }
-  ],
-  "security": [
-    {
-      "BearerAuth": []
-    }
-  ],
-  "paths": {
-    "/users/{userId}": {
-      "parameters": [
-        {
-          "$ref": "#/components/parameters/UserId"
-        }
-      ],
-      "get": {
-        "operationId": "users.get",
-        "summary": "Get a user",
-        "parameters": [
-          {
-            "name": "include",
-            "in": "query",
-            "style": "form",
-            "explode": false,
-            "schema": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          },
-          {
-            "name": "verbose",
-            "in": "query",
-            "schema": {
-              "type": "boolean"
-            }
-          },
-          {
-            "name": "X-Trace-ID",
-            "in": "header",
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "$ref": "#/components/responses/UserResponse"
-          }
-        }
-      },
-      "delete": {
-        "operationId": "users.remove",
-        "summary": "Remove a user",
-        "responses": {
-          "204": {
-            "description": "Removed"
-          }
-        }
-      }
-    },
-    "/users": {
-      "post": {
-        "operationId": "users.create",
-        "summary": "Create a user",
-        "security": [
-          {
-            "ApiKey": []
-          }
-        ],
-        "requestBody": {
-          "required": true,
-          "content": {
-            "application/json": {
-              "schema": {
-                "type": "object",
-                "properties": {
-                  "name": {
-                    "type": "string"
-                  },
-                  "email": {
-                    "type": "string",
-                    "format": "email"
-                  },
-                  "role": {
-                    "type": "string",
-                    "enum": [
-                      "admin",
-                      "member"
-                    ]
-                  }
-                },
-                "required": [
-                  "name",
-                  "email"
-                ],
-                "additionalProperties": false
-              }
-            }
-          }
-        },
-        "responses": {
-          "201": {
-            "description": "Created",
-            "content": {
-              "application/vnd.example+json": {
-                "schema": {
-                  "$ref": "#/components/schemas/User"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/search": {
-      "get": {
-        "operationId": "search.run",
-        "summary": "Search users",
-        "security": [],
-        "parameters": [
-          {
-            "name": "filter",
-            "in": "query",
-            "style": "deepObject",
-            "explode": true,
-            "schema": {
-              "type": "object",
-              "properties": {
-                "query": {
-                  "type": "string"
-                },
-                "page": {
-                  "type": "integer"
-                }
-              },
-              "required": [
-                "query"
-              ],
-              "additionalProperties": false
-            }
-          },
-          {
-            "name": "tags",
-            "in": "query",
-            "style": "form",
-            "explode": true,
-            "schema": {
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Summary",
-            "content": {
-              "text/plain": {
-                "schema": {
-                  "type": "string"
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-  "components": {
-    "parameters": {
-      "UserId": {
-        "name": "userId",
-        "in": "path",
-        "required": true,
-        "schema": {
-          "type": "string"
-        }
-      }
-    },
-    "responses": {
-      "UserResponse": {
-        "description": "A user",
-        "content": {
-          "application/json": {
-            "schema": {
-              "$ref": "#/components/schemas/User"
-            }
-          }
-        }
-      }
-    },
-    "schemas": {
-      "User": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          },
-          "email": {
-            "type": "string",
-            "format": "email"
-          },
-          "role": {
-            "type": "string",
-            "enum": [
-              "admin",
-              "member"
-            ]
-          }
-        },
-        "required": [
-          "id",
-          "name",
-          "email"
-        ],
-        "additionalProperties": false
-      }
-    },
-    "securitySchemes": {
-      "BearerAuth": {
-        "type": "http",
-        "scheme": "bearer"
-      },
-      "ApiKey": {
-        "type": "apiKey",
-        "in": "query",
-        "name": "api_key"
-      }
-    }
-  }
-}

packages/codemode/test/openapi.test.ts

@@ -1,957 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect, Layer, Option } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { CodeMode, OpenAPI, Tool } from "../src/index.js"
-import { inputTypeScript, outputTypeScript } from "../src/tool-schema.js"
-
-const baseUrl = "http://localhost:4096"
-type Document = OpenAPI.Document
-
-type Recorded = {
-  readonly method: string
-  readonly url: string
-  readonly headers: Record<string, string>
-  readonly body: unknown
-}
-
-const opencodeSpec = async (): Promise<Document> => {
-  return Bun.file(new URL("./fixtures/opencode-v2-openapi.json", import.meta.url)).json() as Promise<Document>
-}
-
-const happyPathSpec = async (): Promise<Document> => {
-  return Bun.file(new URL("./fixtures/openapi-happy-path.json", import.meta.url)).json() as Promise<Document>
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const toolAt = (tools: unknown, name: string) =>
-  name.split(".").reduce<unknown>((current, segment) => (isRecord(current) ? current[segment] : undefined), tools)
-
-const recordingClient = (respond: (request: HttpClientRequest.HttpClientRequest) => Response) => {
-  const requests: Array<Recorded> = []
-  const layer = Layer.succeed(HttpClient.HttpClient)(
-    HttpClient.make((request) =>
-      Effect.gen(function* () {
-        const body =
-          request.body._tag === "Uint8Array" ? JSON.parse(new TextDecoder().decode(request.body.body)) : undefined
-        const url = Option.map(HttpClientRequest.toUrl(request), (resolved) => resolved.toString())
-        requests.push({
-          method: request.method,
-          url: Option.getOrElse(url, () => request.url),
-          headers: { ...request.headers },
-          body,
-        })
-        return HttpClientResponse.fromWeb(request, respond(request))
-      }),
-    ),
-  )
-  return { requests, layer }
-}
-
-const json = (value: unknown, status = 200) =>
-  new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } })
-
-const singleOperation = (operation: Record<string, unknown>, method = "get"): Document => ({
-  openapi: "3.1.0",
-  paths: { "/test": { [method]: { operationId: "test", responses: { 200: { description: "Success" } }, ...operation } } },
-})
-
-describe("OpenAPI.fromSpec", () => {
-  test("covers a representative API from generation through execution", async () => {
-    const resolutions: Array<string> = []
-    const client = recordingClient((request) => {
-      const url = Option.getOrElse(HttpClientRequest.toUrl(request), () => new URL(request.url))
-      if (request.method === "POST") {
-        return new Response(
-          JSON.stringify({ id: "user-2", name: "Grace", email: "grace@example.test", role: "admin" }),
-          { status: 201, headers: { "content-type": "application/vnd.example+json" } },
-        )
-      }
-      if (request.method === "DELETE") return new Response(null, { status: 204 })
-      if (url.pathname === "/search") {
-        return new Response("2 matches", { headers: { "content-type": "text/plain" } })
-      }
-      return json({ id: "user-1", name: "Ada", email: "ada@example.test", role: "member" })
-    })
-    const api = OpenAPI.fromSpec({
-      spec: await happyPathSpec(),
-      baseUrl,
-      auth: {
-        resolve: ({ name }) => {
-          resolutions.push(name)
-          return Effect.succeed(
-            name === "BearerAuth"
-              ? { type: "bearer", token: "bearer-secret" }
-              : { type: "apiKey", value: "api-secret" },
-          )
-        },
-      },
-    })
-    const get = toolAt(api.tools, "users.get")
-    const create = toolAt(api.tools, "users.create")
-    const search = toolAt(api.tools, "search.run")
-    const remove = toolAt(api.tools, "users.remove")
-
-    expect(api.skipped).toEqual([])
-    if (!Tool.isDefinition(get) || !Tool.isDefinition(create) || !Tool.isDefinition(search) || !Tool.isDefinition(remove)) {
-      throw new Error("happy-path fixture did not generate every operation")
-    }
-    expect(inputTypeScript(get)).toBe(
-      '{ userId: string; include?: Array<string>; verbose?: boolean; "X-Trace-ID"?: string }',
-    )
-    expect(inputTypeScript(create)).toBe('{ name: string; email: string; role?: "admin" | "member" }')
-    expect(inputTypeScript(search)).toBe("{ filter?: { query: string; page?: number }; tags?: Array<string> }")
-    expect(inputTypeScript(remove)).toBe("{ userId: string }")
-    expect(outputTypeScript(get)).toContain("id: string")
-    expect(outputTypeScript(create)).toContain('role?: "admin" | "member"')
-    expect(outputTypeScript(search)).toBe("string")
-    expect(outputTypeScript(remove)).toBe("null")
-
-    const result = await Effect.runPromise(
-      CodeMode.make({ tools: { api: api.tools } })
-        .execute(`
-          const user = await tools.api.users.get({
-            userId: "user-1",
-            include: ["profile", "permissions"],
-            verbose: true,
-            "X-Trace-ID": "trace-1",
-          })
-          const created = await tools.api.users.create({
-            name: "Grace",
-            email: "grace@example.test",
-            role: "admin",
-          })
-          const summary = await tools.api.search.run({
-            filter: { query: "effect", page: 2 },
-            tags: ["typescript", "runtime"],
-          })
-          const removed = await tools.api.users.remove({ userId: "user-1" })
-          return { user, created, summary, removed }
-        `)
-        .pipe(Effect.provide(client.layer)),
-    )
-
-    expect(result).toMatchObject({
-      ok: true,
-      value: {
-        user: { id: "user-1", name: "Ada" },
-        created: { id: "user-2", name: "Grace" },
-        summary: "2 matches",
-        removed: null,
-      },
-    })
-    expect(resolutions).toEqual(["BearerAuth", "ApiKey", "BearerAuth"])
-    expect(client.requests).toHaveLength(4)
-
-    const getUrl = new URL(client.requests[0]!.url)
-    expect(getUrl.pathname).toBe("/users/user-1")
-    expect(getUrl.searchParams.get("include")).toBe("profile,permissions")
-    expect(getUrl.searchParams.get("verbose")).toBe("true")
-    expect(client.requests[0]!.headers["x-trace-id"]).toBe("trace-1")
-    expect(client.requests[0]!.headers.authorization).toBe("Bearer bearer-secret")
-
-    const createUrl = new URL(client.requests[1]!.url)
-    expect(createUrl.searchParams.get("api_key")).toBe("api-secret")
-    expect(client.requests[1]!.body).toEqual({ name: "Grace", email: "grace@example.test", role: "admin" })
-
-    const searchUrl = new URL(client.requests[2]!.url)
-    expect(searchUrl.searchParams.get("filter[query]")).toBe("effect")
-    expect(searchUrl.searchParams.get("filter[page]")).toBe("2")
-    expect(searchUrl.searchParams.getAll("tags")).toEqual(["typescript", "runtime"])
-    expect(client.requests[2]!.headers.authorization).toBeUndefined()
-    expect(new URL(client.requests[3]!.url).pathname).toBe("/users/user-1")
-    expect(client.requests[3]!.headers.authorization).toBe("Bearer bearer-secret")
-  })
-
-  test("converts representative opencode operations into the expected tool shape", async () => {
-    const spec = await opencodeSpec()
-    const result = OpenAPI.fromSpec({ spec, baseUrl })
-
-    expect(result.skipped).toHaveLength(5)
-    expect(result.skipped).toContainEqual({
-      method: "GET",
-      path: "/api/pty/{ptyID}/connect",
-      reason: "WebSocket operations are not supported",
-    })
-    expect(result.skipped.filter((item) => item.reason === "SSE operations are not supported")).toHaveLength(3)
-    expect(result.skipped).toContainEqual({
-      method: "GET",
-      path: "/api/fs/read/*",
-      reason: "binary responses are not supported",
-    })
-    expect(toolAt(result.tools, "v2.health.get")).not.toBeUndefined()
-    expect(toolAt(result.tools, "v2.session.get")).not.toBeUndefined()
-    expect(toolAt(result.tools, "v2.session.create")).not.toBeUndefined()
-
-    const sessionGet = toolAt(result.tools, "v2.session.get")
-    expect(Tool.isDefinition(sessionGet)).toBe(true)
-    if (!Tool.isDefinition(sessionGet)) throw new Error("v2.session.get was not generated")
-    expect(inputTypeScript(sessionGet)).toBe("{ sessionID: string }")
-    expect(outputTypeScript(sessionGet)).toContain("id: string")
-    expect(outputTypeScript(sessionGet)).toContain("additions: number")
-
-    const switchAgent = toolAt(result.tools, "v2.session.switchAgent")
-    expect(Tool.isDefinition(switchAgent)).toBe(true)
-    if (!Tool.isDefinition(switchAgent)) throw new Error("v2.session.switchAgent was not generated")
-    expect(inputTypeScript(switchAgent)).toBe("{ sessionID: string; agent: string }")
-
-    const contextEntryPut = toolAt(result.tools, "v2.session.contextEntry.put")
-    expect(Tool.isDefinition(contextEntryPut)).toBe(true)
-    if (!Tool.isDefinition(contextEntryPut)) throw new Error("v2.session.contextEntry.put was not generated")
-    expect(inputTypeScript(contextEntryPut)).toBe("{ sessionID: string; key: string; value: unknown }")
-    expect(toolAt(result.tools, "v2_session_context_entry_put_2")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.pty.connect")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.session.log")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.event.subscribe")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.fs.read")).toBeUndefined()
-    expect(toolAt(result.tools, "v2.pty.connectToken")).not.toBeUndefined()
-  })
-
-  test("preserves operation path sanitization and collision handling", () => {
-    const response = { responses: { 200: { description: "Success" } } }
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        paths: {
-          "/first": { get: { ...response, operationId: "group.item" } },
-          "/second": { get: { ...response, operationId: "group.item" } },
-          "/third": { get: { ...response, operationId: "group..other" } },
-        },
-      },
-    })
-
-    expect(Tool.isDefinition(toolAt(result.tools, "group.item"))).toBe(true)
-    expect(Tool.isDefinition(toolAt(result.tools, "group_item_2"))).toBe(true)
-    expect(Tool.isDefinition(toolAt(result.tools, "group.operation.other"))).toBe(true)
-  })
-
-  test("synthesizes flat operation IDs from methods and paths", () => {
-    const response = { responses: { 200: { description: "Success" } } }
-    const tools = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        paths: {
-          "/users": { get: response, post: response },
-          "/users/{id}": { get: response, patch: response, delete: response },
-          "/organizations/{organizationId}/users/{id}": { get: response },
-        },
-      },
-    }).tools
-
-    for (const path of [
-      "getUsers",
-      "postUsers",
-      "getUsersById",
-      "patchUsersById",
-      "deleteUsersById",
-      "getOrganizationsByOrganizationidUsersById",
-    ]) {
-      expect(Tool.isDefinition(toolAt(tools, path))).toBe(true)
-    }
-  })
-
-  test("lets operation parameters override matching path parameters", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              parameters: [{ name: "limit", in: "query", schema: { type: "string" } }],
-              get: {
-                operationId: "test",
-                parameters: [{ name: "limit", in: "query", required: true, schema: { type: "number" } }],
-                responses: { 200: { description: "Success" } },
-              },
-            },
-          },
-        },
-      }).tools,
-      "test",
-    )
-
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-    expect(inputTypeScript(tool)).toBe("{ limit: number }")
-  })
-
-  test("normalizes OpenAPI 3.0 schemas with Effect", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.0.3",
-        paths: {
-          "/search": {
-            get: {
-              operationId: "search",
-              parameters: [
-                {
-                  in: "query",
-                  name: "value",
-                  schema: { type: "string", nullable: true, minLength: 2 },
-                },
-              ],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-        },
-      },
-    })
-    const search = toolAt(result.tools, "search")
-
-    expect(Tool.isDefinition(search)).toBe(true)
-    if (!Tool.isDefinition(search)) throw new Error("search was not generated")
-    expect(inputTypeScript(search)).toBe("{ value?: string | null }")
-    const schema: unknown = search.input
-    const input = isRecord(schema) ? schema : {}
-    const properties = isRecord(input.properties) ? input.properties : {}
-    const value = isRecord(properties.value) ? properties.value : {}
-    expect(value.minLength).toBe(2)
-  })
-
-  test("preserves schema-local definitions alongside component definitions", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              get: {
-                operationId: "test",
-                responses: {
-                  200: {
-                    description: "Success",
-                    content: {
-                      "application/json": {
-                        schema: { $ref: "#/$defs/Local", $defs: { Local: { type: "string" } } },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          components: { schemas: { Global: { type: "number" } } },
-        },
-      }).tools,
-      "test",
-    )
-
-    if (!Tool.isDefinition(tool) || !isRecord(tool.output)) throw new Error("test output was not generated")
-    expect(tool.output.$defs).toMatchObject({ Local: { type: "string" }, Global: { type: "number" } })
-  })
-
-  test("documents that the opencode fixture is unauthenticated", async () => {
-    const spec = await opencodeSpec()
-    const components = isRecord(spec.components) ? spec.components : {}
-    const result = OpenAPI.fromSpec({ spec, baseUrl })
-
-    expect(spec.security).toStrictEqual([])
-    expect(isRecord(components.securitySchemes) ? Object.keys(components.securitySchemes) : []).toStrictEqual([])
-    const health = toolAt(result.tools, "v2.health.get")
-    const healthInput = isRecord(health) ? health.input : undefined
-    expect(healthInput).toMatchObject({ type: "object", properties: {} })
-    const input = isRecord(healthInput) ? healthInput : {}
-    expect(Object.keys(isRecord(input.properties) ? input.properties : {})).toStrictEqual([])
-  })
-
-  test("exposes real opencode operations through CodeMode discovery", async () => {
-    const { layer } = recordingClient(() => json({}))
-    const runtime = CodeMode.make({
-      tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools },
-    })
-    const result = await Effect.runPromise(
-      runtime
-        .execute(
-          `
-        return await tools.$codemode.search({ query: "global health", namespace: "opencode", limit: 1 })
-      `,
-        )
-        .pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: true })
-    if (!result.ok) return
-    expect(result.value).toMatchObject({
-      items: [
-        {
-          path: "tools.opencode.v2.health.get",
-          description: "Check whether the API server is ready to accept requests.",
-        },
-      ],
-    })
-    expect(JSON.stringify(result.value)).toContain("healthy: true")
-  })
-
-  test("invokes real opencode path parameters and JSON request bodies", async () => {
-    const { requests, layer } = recordingClient((request) => {
-      if (request.method === "GET") return json({ id: "ses_123" })
-      return json({ id: "ses_456" })
-    })
-    const runtime = CodeMode.make({
-      tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools },
-    })
-
-    const result = await Effect.runPromise(
-      runtime
-        .execute(
-          `
-          const existing = await tools.opencode.v2.session.get({ sessionID: "ses_123" })
-          const created = await tools.opencode.v2.session.create({ id: "ses_456" })
-          return { existing, created }
-        `,
-        )
-        .pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: true })
-    expect(requests).toHaveLength(2)
-    expect(requests[0]).toMatchObject({ method: "GET", body: undefined })
-    expect(new URL(requests[0]!.url).pathname).toBe("/api/session/ses_123")
-    expect(requests[1]).toMatchObject({
-      method: "POST",
-      url: "http://localhost:4096/api/session",
-      body: { id: "ses_456" },
-    })
-  })
-
-  test("serializes deep-object query parameters from the opencode fixture", async () => {
-    const client = recordingClient(() => json({ directory: "/tmp" }))
-    const location = toolAt(OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools, "v2.location.get")
-    if (!Tool.isDefinition(location)) throw new Error("v2.location.get was not generated")
-
-    await Effect.runPromise(
-      location.run({ location: { directory: "/tmp", workspace: "workspace-1" } }).pipe(Effect.provide(client.layer)),
-    )
-
-    const url = new URL(client.requests[0]!.url)
-    expect(url.searchParams.get("location[directory]")).toBe("/tmp")
-    expect(url.searchParams.get("location[workspace]")).toBe("workspace-1")
-  })
-
-  test("serializes supported simple and form parameter shapes", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        paths: {
-          "/items/{keys}": {
-            get: {
-              operationId: "items",
-              parameters: [
-                { name: "keys", in: "path", required: true, schema: { type: "array", items: { type: "string" } } },
-                { name: "tags", in: "query", style: "form", explode: false, schema: { type: "array" } },
-                { name: "filter", in: "query", style: "form", explode: true, schema: { type: "object" } },
-                { name: "nullable", in: "query", required: true, schema: { type: ["string", "null"] } },
-                { name: "constructor", in: "query", schema: { type: "string" } },
-                { name: "meta", in: "header", style: "simple", explode: true, schema: { type: "object" } },
-              ],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-        },
-      },
-    })
-    const tool = toolAt(result.tools, "items")
-    if (!Tool.isDefinition(tool)) throw new Error("items was not generated")
-
-    await Effect.runPromise(
-      tool
-        .run({
-          keys: ["a!", "b*"],
-          tags: ["x", "y"],
-          filter: { state: "open", page: 2 },
-          nullable: null,
-          constructor_2: "safe",
-          meta: { a: "b", c: "d" },
-        })
-        .pipe(Effect.provide(client.layer)),
-    )
-
-    const url = new URL(client.requests[0]!.url)
-    expect(url.pathname).toBe("/items/a%21,b%2A")
-    expect(url.searchParams.get("tags")).toBe("x,y")
-    expect(url.searchParams.get("state")).toBe("open")
-    expect(url.searchParams.get("page")).toBe("2")
-    expect(url.searchParams.get("nullable")).toBe("null")
-    expect(url.searchParams.get("constructor")).toBe("safe")
-    expect(client.requests[0]!.headers.meta).toBe("a=b,c=d")
-    await expect(
-      Effect.runPromise(tool.run({ keys: [undefined] }).pipe(Effect.provide(client.layer))),
-    ).rejects.toThrow("unsupported nested value")
-  })
-
-  test("skips unsupported parameter encodings and malformed security", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        openapi: "3.1.0",
-        security: [{ bearer: [] }],
-        paths: {
-          "/cookie": {
-            get: {
-              operationId: "cookie",
-              parameters: [{ name: "session", in: "cookie", schema: { type: "string" } }],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-          "/reserved": {
-            get: {
-              operationId: "reserved",
-              parameters: [{ name: "query", in: "query", allowReserved: true, schema: { type: "string" } }],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-          "/invalid-style": {
-            get: {
-              operationId: "invalidStyle",
-              parameters: [{ name: "query", in: "query", style: 42, schema: { type: "string" } }],
-              responses: { 200: { description: "Success" } },
-            },
-          },
-          "/security": {
-            get: { operationId: "security", security: null, responses: { 200: { description: "Success" } } },
-          },
-        },
-      },
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped.map((item) => item.reason)).toEqual([
-      "cookie parameter 'session' is not supported",
-      "parameter 'query' uses unsupported allowReserved encoding",
-      "parameter 'query' has an invalid style",
-      "security declaration is not an array",
-    ])
-  })
-
-  test("fails closed on prototype-named missing security schemes", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: singleOperation({ security: [JSON.parse('{"__proto__":[]}')] }),
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped[0]?.reason).toBe("security requirement references missing or malformed scheme: __proto__")
-  })
-
-  test("resolves bearer authentication without exposing it as input", async () => {
-    const contexts: Array<Parameters<OpenAPI.AuthResolver>[0]> = []
-    const client = recordingClient(() => json({ ok: true }))
-    const spec = {
-      ...singleOperation({ operationId: undefined }),
-      security: [{ bearer: [] }],
-      components: { securitySchemes: { bearer: { type: "http", scheme: "bearer" } } },
-    } satisfies Document
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec,
-        auth: {
-          resolve: (context) => {
-            contexts.push(context)
-            return Effect.succeed({ type: "bearer", token: "secret" })
-          },
-        },
-      }).tools,
-      "getTest",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await Effect.runPromise(tool.run({}).pipe(Effect.provide(client.layer)))
-
-    expect(inputTypeScript(tool)).toBe("{}")
-    expect(client.requests[0]!.headers.authorization).toBe("Bearer secret")
-    expect(contexts).toEqual([
-      {
-        name: "bearer",
-        definition: { type: "http", scheme: "bearer" },
-        scopes: [],
-        operation: {
-          operationId: undefined,
-          method: "GET",
-          path: "/test",
-          summary: undefined,
-          description: undefined,
-        },
-      },
-    ])
-  })
-
-  test("applies authentication carriers without prototype or collision loss", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const authenticated = (security: ReadonlyArray<Record<string, ReadonlyArray<string>>>, schemes: Record<string, unknown>) =>
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: { ...singleOperation({}), security, components: { securitySchemes: schemes } },
-        auth: { resolve: () => Effect.succeed({ type: "apiKey", value: "secret" }) },
-      })
-    const prototype = toolAt(
-      authenticated([{ key: [] }], { key: { type: "apiKey", in: "query", name: "__proto__" } }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(prototype)) throw new Error("prototype auth tool was not generated")
-
-    await Effect.runPromise(prototype.run({}).pipe(Effect.provide(client.layer)))
-    expect(new URL(client.requests[0]!.url).searchParams.get("__proto__")).toBe("secret")
-
-    const duplicate = toolAt(
-      authenticated(
-        [{ first: [], second: [] }],
-        {
-          first: { type: "apiKey", in: "header", name: "x-key" },
-          second: { type: "apiKey", in: "header", name: "x-key" },
-        },
-      ).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(duplicate)) throw new Error("duplicate auth tool was not generated")
-    await expect(Effect.runPromise(duplicate.run({}).pipe(Effect.provide(client.layer)))).rejects.toThrow(
-      "multiple credentials",
-    )
-
-    const cookie = authenticated([{ key: [] }], { key: { type: "apiKey", in: "cookie", name: "session" } })
-    expect(cookie.tools).toEqual({})
-    expect(cookie.skipped[0]?.reason).toBe("cookie authentication 'key' is not supported")
-
-    const alternative = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        ...singleOperation({}),
-        security: [{ cookie: [] }, { bearer: [] }],
-        components: {
-          securitySchemes: {
-            cookie: { type: "apiKey", in: "cookie", name: "session" },
-            bearer: { type: "http", scheme: "bearer" },
-          },
-        },
-      },
-      auth: {
-        resolve: ({ name }) =>
-          Effect.succeed(name === "bearer" ? { type: "bearer", token: "secret" } : undefined),
-      },
-    })
-    const alternativeTool = toolAt(alternative.tools, "test")
-    if (!Tool.isDefinition(alternativeTool)) throw new Error("supported auth alternative was not generated")
-    await Effect.runPromise(alternativeTool.run({}).pipe(Effect.provide(client.layer)))
-    expect(client.requests.at(-1)?.headers.authorization).toBe("Bearer secret")
-  })
-
-  test("honors server precedence and rejects ambiguous base URLs", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const spec = {
-      ...singleOperation({ servers: [{ url: "https://operation.example/v1" }] }),
-      servers: [{ url: "https://document.example" }],
-    } satisfies Document
-    const tool = toolAt(OpenAPI.fromSpec({ spec }).tools, "test")
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await Effect.runPromise(tool.run({}).pipe(Effect.provide(client.layer)))
-    expect(client.requests[0]?.url).toBe("https://operation.example/v1/test")
-
-    const invalid = OpenAPI.fromSpec({ spec, baseUrl: "https://example.com/api?tenant=one" })
-    expect(invalid.tools).toEqual({})
-    expect(invalid.skipped[0]?.reason).toContain("unsupported query string or fragment")
-
-    const malformed = OpenAPI.fromSpec({ spec, baseUrl: "https:/example.com" })
-    expect(malformed.tools).toEqual({})
-    expect(malformed.skipped[0]?.reason).toContain("not an absolute HTTP(S) URL")
-  })
-
-  test("resolves chained response refs before detecting unsupported transports", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        ...singleOperation({ responses: { 200: { $ref: "#/components/responses/First" } } }),
-        components: {
-          responses: {
-            First: { $ref: "#/components/responses/Stream" },
-            Stream: { content: { "text/event-stream": { schema: { type: "string" } } } },
-          },
-        },
-      },
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped[0]?.reason).toBe("SSE operations are not supported")
-  })
-
-  test("resolves response schemas before detecting binary output", () => {
-    const result = OpenAPI.fromSpec({
-      baseUrl,
-      spec: {
-        ...singleOperation({
-          responses: {
-            200: {
-              content: { "text/plain": { schema: { $ref: "#/components/schemas/File" } } },
-            },
-          },
-        }),
-        components: { schemas: { File: { type: "string", format: "binary" } } },
-      },
-    })
-
-    expect(result.tools).toEqual({})
-    expect(result.skipped[0]?.reason).toBe("binary responses are not supported")
-  })
-
-  test("validates composite parameters before resolving auth", async () => {
-    const resolutions: Array<string> = []
-    const client = recordingClient(() => json({ ok: true }))
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          ...singleOperation({
-            parameters: [{ name: "filter", in: "query", style: "form", explode: true, schema: { type: "object" } }],
-          }),
-          security: [{ bearer: [] }],
-          components: { securitySchemes: { bearer: { type: "http", scheme: "bearer" } } },
-        },
-        auth: {
-          resolve: ({ name }) => {
-            resolutions.push(name)
-            return Effect.succeed({ type: "bearer", token: "secret" })
-          },
-        },
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await expect(
-      Effect.runPromise(tool.run({ filter: { value: undefined } }).pipe(Effect.provide(client.layer))),
-    ).rejects.toThrow("unsupported nested value")
-    expect(resolutions).toEqual([])
-    expect(client.requests).toEqual([])
-  })
-
-  test("preserves JSON media types and rejects unencodable bodies", async () => {
-    const client = recordingClient(() => json({ ok: true }))
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: { "application/merge-patch+json": { schema: { type: "object" } } },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    await Effect.runPromise(tool.run({ body: { name: "updated" } }).pipe(Effect.provide(client.layer)))
-    expect(client.requests[0]!.headers["content-type"]).toBe("application/merge-patch+json")
-    const cyclic: Record<string, unknown> = {}
-    cyclic.self = cyclic
-    await expect(Effect.runPromise(tool.run({ body: cyclic }).pipe(Effect.provide(client.layer)))).rejects.toThrow(
-      "Invalid JSON body",
-    )
-  })
-
-  test("rejects oversized and malformed JSON responses", async () => {
-    const tool = toolAt(OpenAPI.fromSpec({ baseUrl, spec: singleOperation({}) }).tools, "test")
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-    const oversized = recordingClient(
-      () => new Response(null, { headers: { "content-length": String(50 * 1024 * 1024 + 1) } }),
-    )
-    const malformed = recordingClient(
-      () => new Response("{", { headers: { "content-type": "application/json" } }),
-    )
-    const chunked = recordingClient(() => new Response(new Uint8Array(50 * 1024 * 1024 + 1)))
-
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(oversized.layer)))).rejects.toThrow(
-      "response exceeds 50 MiB",
-    )
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(malformed.layer)))).rejects.toThrow(
-      "returned malformed JSON",
-    )
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(chunked.layer)))).rejects.toThrow(
-      "response exceeds 50 MiB",
-    )
-  })
-
-  test("keeps non-JSON responses raw and unions every success output", async () => {
-    const spec = singleOperation({
-      responses: {
-        200: { description: "Text", content: { "text/plain": { schema: { type: "string" } } } },
-        204: { description: "Empty" },
-      },
-    })
-    const tool = toolAt(OpenAPI.fromSpec({ baseUrl, spec }).tools, "test")
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-    const client = recordingClient(() => new Response("123", { headers: { "content-type": "text/plain" } }))
-
-    expect(outputTypeScript(tool)).toBe("string | null")
-    await expect(Effect.runPromise(tool.run({}).pipe(Effect.provide(client.layer)))).resolves.toBe("123")
-  })
-
-  test("fails missing required parameters before auth and network", async () => {
-    const { requests, layer } = recordingClient(() => json({}))
-    const runtime = CodeMode.make({
-      tools: { opencode: OpenAPI.fromSpec({ spec: await opencodeSpec(), baseUrl }).tools },
-    })
-
-    const result = await Effect.runPromise(
-      runtime.execute("return await tools.opencode.v2.session.get({})").pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: false })
-    expect(JSON.stringify(result)).toContain("Missing required path parameter 'sessionID'")
-    expect(requests).toHaveLength(0)
-  })
-
-  test("prefixes cross-location collisions and reconstructs the HTTP request", async () => {
-    const spec = {
-      openapi: "3.1.0",
-      info: { title: "collision", version: "1.0.0" },
-      paths: {
-        "/echo": {
-          post: {
-            operationId: "echo",
-            requestBody: {
-              required: true,
-              content: { "application/json": { schema: { type: "string" } } },
-            },
-            responses: { "204": { description: "Echoed" } },
-          },
-        },
-        "/things/{id}": {
-          post: {
-            operationId: "things.update",
-            parameters: [
-              { name: "id", in: "path", required: true, schema: { type: "string" } },
-              { name: "id", in: "query", required: true, schema: { type: "string" } },
-              { name: "path_id", in: "query", schema: { type: "string" } },
-              { name: "id", in: "header", required: true, schema: { type: "string" } },
-            ],
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    properties: { id: { type: "string" } },
-                    required: ["id"],
-                    additionalProperties: false,
-                  },
-                },
-              },
-            },
-            responses: { "204": { description: "Updated" } },
-          },
-        },
-      },
-    } satisfies Document
-    const { requests, layer } = recordingClient(() => new Response(null, { status: 204 }))
-    const tools = OpenAPI.fromSpec({ spec, baseUrl }).tools
-    const update = toolAt(tools, "things.update")
-    const echo = toolAt(tools, "echo")
-
-    expect(Tool.isDefinition(update)).toBe(true)
-    if (!Tool.isDefinition(update)) throw new Error("things.update was not generated")
-    expect(inputTypeScript(update)).toBe(
-      "{ path_id: string; query_id: string; path_id_2?: string; header_id: string; body_id: string }",
-    )
-    expect(Tool.isDefinition(echo)).toBe(true)
-    if (!Tool.isDefinition(echo)) throw new Error("echo was not generated")
-    expect(inputTypeScript(echo)).toBe("{ body: string }")
-
-    const runtime = CodeMode.make({ tools })
-    const result = await Effect.runPromise(
-      runtime
-        .execute(
-          `
-            const updated = await tools.things.update({ path_id: "path", query_id: "query", path_id_2: "literal", header_id: "header", body_id: "body" })
-            const echoed = await tools.echo({ body: "hello" })
-            return { updated, echoed }
-          `,
-        )
-        .pipe(Effect.provide(layer)),
-    )
-
-    expect(result).toMatchObject({ ok: true })
-    expect(requests).toHaveLength(2)
-    expect(new URL(requests[0]!.url).pathname).toBe("/things/path")
-    expect(new URL(requests[0]!.url).searchParams.get("id")).toBe("query")
-    expect(new URL(requests[0]!.url).searchParams.get("path_id")).toBe("literal")
-    expect(requests[0]!.headers.id).toBe("header")
-    expect(requests[0]!.body).toStrictEqual({ id: "body" })
-    expect(requests[1]!.body).toBe("hello")
-  })
-
-  test("keeps bodies nested when flattening would lose schema semantics", () => {
-    const body = (schema: Record<string, unknown>, required = true) => ({
-      required,
-      content: { "application/json": { schema } },
-    })
-    const spec = {
-      openapi: "3.1.0",
-      info: { title: "bodies", version: "1.0.0" },
-      paths: Object.fromEntries(
-        [
-          [
-            "optional",
-            body(
-              {
-                type: "object",
-                properties: { name: { type: "string" } },
-                required: ["name"],
-                additionalProperties: false,
-              },
-              false,
-            ),
-          ],
-          ["dictionary", body({ type: "object", additionalProperties: { type: "string" } })],
-          [
-            "composed",
-            body({
-              type: "object",
-              allOf: [{ type: "object", properties: { name: { type: "string" } }, required: ["name"] }],
-              additionalProperties: false,
-            }),
-          ],
-          [
-            "nullable",
-            body({
-              type: ["object", "null"],
-              properties: { name: { type: "string" } },
-              additionalProperties: false,
-            }),
-          ],
-        ].map(([name, requestBody]) => [
-          `/body/${name}`,
-          {
-            post: {
-              operationId: `body.${name}`,
-              requestBody,
-              responses: { "204": { description: "Accepted" } },
-            },
-          },
-        ]),
-      ),
-    } satisfies Document
-    const tools = OpenAPI.fromSpec({ spec, baseUrl }).tools
-
-    for (const name of ["optional", "dictionary", "composed", "nullable"]) {
-      const tool = toolAt(tools, `body.${name}`)
-      expect(Tool.isDefinition(tool)).toBe(true)
-      if (!Tool.isDefinition(tool)) throw new Error(`body.${name} was not generated`)
-      const input = isRecord(tool.input) ? tool.input : {}
-      expect(Object.keys(isRecord(input.properties) ? input.properties : {})).toStrictEqual(["body"])
-    }
-    const optional = toolAt(tools, "body.optional")
-    if (!Tool.isDefinition(optional)) throw new Error("body.optional was not generated")
-    expect(inputTypeScript(optional)).toBe("{ body?: { name: string } }")
-  })
-})

packages/codemode/test/parity.test.ts

@@ -3,7 +3,7 @@ import { Effect } from "effect"
 import { CodeMode } from "../src/index.js"
 import { ToolRuntime } from "../src/tool-runtime.js"
 
-// Runs a CodeMode program with no host tools and returns the CodeMode.Result. These tests pin the
+// Runs a CodeMode program with no host tools and returns the ExecuteResult. These tests pin the
 // JS-parity behaviors for the "99% of ordinary defensive JavaScript just works" goal: cases where
 // a strict interpreter would throw but idiomatic JS yields undefined / succeeds.
 //

packages/codemode/test/promise.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Schema } from "effect"
-import { CodeMode, Tool, toolError } from "../src/index.js"
+import { CodeMode, Tool, toolError, type ExecuteResult, type ExecutionLimits } from "../src/index.js"
 
 // Wave 5 acceptance suite: first-class promise values. Un-awaited tool calls start eagerly on
 // supervised fibers, `await` settles them, and Promise.all/allSettled/race/resolve/reject are
@@ -48,10 +48,7 @@ const failingTool = Tool.make({
   run: () => Effect.fail(toolError("Lookup refused")),
 })
 
-const run = (
-  code: string,
-  options: { trace?: Trace; limits?: CodeMode.ExecutionLimits } = {},
-): Promise<CodeMode.Result> => {
+const run = (code: string, options: { trace?: Trace; limits?: ExecutionLimits } = {}): Promise<ExecuteResult> => {
   const trace = options.trace ?? makeTrace()
   return Effect.runPromise(
     CodeMode.execute({
@@ -62,13 +59,13 @@ const run = (
   )
 }
 
-const value = async (code: string, options: { trace?: Trace; limits?: CodeMode.ExecutionLimits } = {}) => {
+const value = async (code: string, options: { trace?: Trace; limits?: ExecutionLimits } = {}) => {
   const result = await run(code, options)
   if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
   return result.value
 }
 
-const error = async (code: string, options: { trace?: Trace; limits?: CodeMode.ExecutionLimits } = {}) => {
+const error = async (code: string, options: { trace?: Trace; limits?: ExecutionLimits } = {}) => {
   const result = await run(code, options)
   if (result.ok) throw new Error(`expected failure, got value ${JSON.stringify(result.value)}`)
   return result.error

packages/codemode/test/signature.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Schema } from "effect"
-import { CodeMode, Tool } from "../src/index.js"
-import { inputTypeScript, jsonSchemaToTypeScript, outputTypeScript } from "../src/tool-schema.js"
+import { CodeMode } from "../src/index.js"
+import { Tool, inputTypeScript, jsonSchemaToTypeScript, outputTypeScript } from "../src/tool.js"
 
 // A raw JSON Schema tool in the shape an MCP adapter produces: render-only input schema
 // whose property descriptions and constraints must surface as JSDoc in pretty signatures.
@@ -40,21 +40,21 @@ describe("pretty signature rendering", () => {
       [
         "{",
         "  /** Repository owner */",
-        "  owner: string,",
+        "  owner: string",
         "  /** Cursor from the previous response's pageInfo */",
-        "  after?: string,",
+        "  after?: string",
         "  /**",
         "   * Results per page",
         "   * @default 30",
         "   */",
-        "  perPage?: number,",
+        "  perPage?: number",
         "  /**",
         "   * Filter by labels",
         "   * @minItems 1",
         "   * @maxItems 10",
         "   */",
-        "  labels?: Array<string>,",
-        '  state?: "open" | "closed",',
+        "  labels?: Array<string>",
+        '  state?: "open" | "closed"',
         "}",
       ].join("\n"),
     )
@@ -83,24 +83,18 @@ describe("pretty signature rendering", () => {
       true,
     )
     expect(pretty).toBe(
-      [
-        "{",
-        "  /** Search filter */",
-        "  filter?: {",
-        "    /** Issue state */",
-        "    state?: string,",
-        "  },",
-        "}",
-      ].join("\n"),
+      ["{", "  /** Search filter */", "  filter?: {", "    /** Issue state */", "    state?: string", "  }", "}"].join(
+        "\n",
+      ),
     )
   })
 
   test("Effect Schema annotations become JSDoc on input and output fields", () => {
     expect(inputTypeScript(lookupOrder, true)).toBe(
-      ["{", "  /** Order identifier */", "  id: string,", "  verbose?: boolean,", "}"].join("\n"),
+      ["{", "  /** Order identifier */", "  id: string", "  verbose?: boolean", "}"].join("\n"),
     )
     expect(outputTypeScript(lookupOrder, true)).toBe(
-      ["{", "  /** Current order status */", "  status: string,", "}"].join("\n"),
+      ["{", "  /** Current order status */", "  status: string", "}"].join("\n"),
     )
   })
 
@@ -135,7 +129,7 @@ describe("pretty signature rendering", () => {
       { type: "object", properties: { size: { type: "number", default: 1n } } },
       true,
     )
-    expect(pretty).toBe(["{", "  size?: number,", "}"].join("\n"))
+    expect(pretty).toBe(["{", "  size?: number", "}"].join("\n"))
   })
 
   test("neutralizes */ inside descriptions so nothing closes the comment early", () => {
@@ -156,7 +150,7 @@ describe("pretty signature rendering", () => {
       true,
     )
     expect(pretty).toBe(
-      ["{", "  /**", "   * First line", "   *", "   * Second line", "   */", "  query?: string,", "}"].join("\n"),
+      ["{", "  /**", "   * First line", "   *", "   * Second line", "   */", "  query?: string", "}"].join("\n"),
     )
   })
 
@@ -165,8 +159,8 @@ describe("pretty signature rendering", () => {
       $ref: "#/$defs/Node",
       $defs: { Node: { type: "object", properties: { child: { $ref: "#/$defs/Node" }, name: { type: "string" } } } },
     } as const
-    expect(jsonSchemaToTypeScript(cyclic)).toBe("{ child?: unknown; name?: string }")
-    expect(jsonSchemaToTypeScript(cyclic, true)).toContain("child?: unknown")
+    expect(jsonSchemaToTypeScript(cyclic)).toBe("{ child?: Node; name?: string }")
+    expect(jsonSchemaToTypeScript(cyclic, true)).toContain("child?: Node")
 
     let deep: Record<string, unknown> = { type: "string" }
     for (let level = 0; level < 12; level += 1) deep = { type: "object", properties: { next: deep } }
@@ -176,43 +170,6 @@ describe("pretty signature rendering", () => {
       expect(rendered).toContain("next?:")
     }
   })
-
-  test("intersects ref and union siblings instead of discarding them", () => {
-    expect(
-      jsonSchemaToTypeScript({
-        $ref: "#/$defs/User",
-        properties: { active: { type: "boolean" } },
-        required: ["active"],
-        $defs: {
-          User: { type: "object", properties: { id: { type: "string" } }, required: ["id"] },
-        },
-      }),
-    ).toBe("{ id: string } & { active: boolean }")
-    expect(
-      jsonSchemaToTypeScript({
-        type: "object",
-        properties: { common: { type: "boolean" } },
-        required: ["common"],
-        anyOf: [
-          { type: "object", properties: { name: { type: "string" } }, required: ["name"] },
-          { type: "object", properties: { count: { type: "number" } }, required: ["count"] },
-        ],
-      }),
-    ).toBe("({ name: string } | { count: number }) & { common: boolean }")
-    expect(jsonSchemaToTypeScript({ $ref: "https://example.com/schema.json" })).toBe("unknown")
-    expect(
-      jsonSchemaToTypeScript({
-        $ref: "#/$defs/User/properties/id",
-        $defs: { User: { type: "object" }, id: { type: "string" } },
-      }),
-    ).toBe("unknown")
-    expect(
-      jsonSchemaToTypeScript({
-        type: ["object", "null"],
-        properties: { name: { type: "string" } },
-      }),
-    ).toBe("{ name?: string } | null")
-  })
 })
 
 describe("non-identifier property names render as quoted keys", () => {
@@ -241,12 +198,12 @@ describe("non-identifier property names render as quoted keys", () => {
     expect(jsonSchemaToTypeScript(rawSchema, true)).toBe(
       [
         "{",
-        '  "123"?: number,',
-        '  "foo-bar"?: string,',
-        '  "@type": string,',
+        '  "123"?: number',
+        '  "foo-bar"?: string',
+        '  "@type": string',
         "  /** Dotted name */",
-        '  "x.y"?: number,',
-        "  plain?: boolean,",
+        '  "x.y"?: number',
+        "  plain?: boolean",
         "}",
       ].join("\n"),
     )
@@ -265,7 +222,7 @@ describe("non-identifier property names render as quoted keys", () => {
     })
     expect(inputTypeScript(tool)).toContain('"foo-bar"?: string')
     expect(outputTypeScript(tool)).toBe('{ "content-type": string }')
-    expect(outputTypeScript(tool, true)).toBe(["{", '  "content-type": string,', "}"].join("\n"))
+    expect(outputTypeScript(tool, true)).toBe(["{", '  "content-type": string', "}"].join("\n"))
   })
 
   test("Effect Schema structs with non-identifier field names quote too", () => {
@@ -275,7 +232,7 @@ describe("non-identifier property names render as quoted keys", () => {
       run: () => Effect.succeed(null),
     })
     expect(inputTypeScript(tool)).toBe('{ "foo-bar": string; plain?: number }')
-    expect(inputTypeScript(tool, true)).toBe(["{", '  "foo-bar": string,', "  plain?: number,", "}"].join("\n"))
+    expect(inputTypeScript(tool, true)).toBe(["{", '  "foo-bar": string', "  plain?: number", "}"].join("\n"))
   })
 })
 
@@ -311,34 +268,9 @@ describe("union schemas render every alternative", () => {
     expect(inputTypeScript(tool)).toBe("{ value?: string | number }")
     expect(outputTypeScript(tool)).toBe("number | boolean")
   })
-
-  test("allOf renders intersections with parenthesized union members", () => {
-    const schema = {
-      allOf: [{ type: "object", properties: { id: { type: "string" } } }, { type: ["string", "null"] }],
-    } as const
-    expect(jsonSchemaToTypeScript(schema)).toBe("{ id?: string } & (string | null)")
-  })
-
-  test("allOf does not discard an unresolved constraint", () => {
-    expect(jsonSchemaToTypeScript({ allOf: [{ type: "string" }, { $ref: "https://example.com/external.json" }] })).toBe(
-      "unknown",
-    )
-    expect(
-      jsonSchemaToTypeScript({
-        allOf: [{ type: "string" }, { allOf: [{ $ref: "https://example.com/external.json" }] }],
-      }),
-    ).toBe("unknown")
-    expect(
-      jsonSchemaToTypeScript({
-        type: "string",
-        allOf: [{ $ref: "#/$defs/Constraint" }],
-        $defs: { Constraint: { description: "TypeScript-neutral constraint" } },
-      }),
-    ).toBe("string")
-  })
 })
 
-describe("JSDoc signatures in catalogs and search results", () => {
+describe("pretty signatures in search results", () => {
   const runtime = CodeMode.make({ tools: { github: { list_issues: listIssues }, orders: { lookup: lookupOrder } } })
 
   const search = async (query: string) => {
@@ -347,7 +279,7 @@ describe("JSDoc signatures in catalogs and search results", () => {
     )
     expect(result.ok).toBe(true)
     if (!result.ok) throw new Error("search failed")
-    return result.value as { items: Array<{ path: string; signature: string }>; remaining: number }
+    return result.value as { items: Array<{ path: string; signature: string }>; total: number }
   }
 
   test("a raw JSON Schema (MCP-style) tool's result signature carries field JSDoc and tags", async () => {
@@ -357,21 +289,21 @@ describe("JSDoc signatures in catalogs and search results", () => {
       [
         "tools.github.list_issues(input: {",
         "  /** Repository owner */",
-        "  owner: string,",
+        "  owner: string",
         "  /** Cursor from the previous response's pageInfo */",
-        "  after?: string,",
+        "  after?: string",
         "  /**",
         "   * Results per page",
         "   * @default 30",
         "   */",
-        "  perPage?: number,",
+        "  perPage?: number",
         "  /**",
         "   * Filter by labels",
         "   * @minItems 1",
         "   * @maxItems 10",
         "   */",
-        "  labels?: Array<string>,",
-        '  state?: "open" | "closed",',
+        "  labels?: Array<string>",
+        '  state?: "open" | "closed"',
         "}): Promise<unknown>",
       ].join("\n"),
     )
@@ -385,65 +317,25 @@ describe("JSDoc signatures in catalogs and search results", () => {
         [
           "tools.orders.lookup(input: {",
           "  /** Order identifier */",
-          "  id: string,",
-          "  verbose?: boolean,",
+          "  id: string",
+          "  verbose?: boolean",
           "}): Promise<{",
           "  /** Current order status */",
-          "  status: string,",
+          "  status: string",
           "}>",
         ].join("\n"),
       )
     }
   })
 
-  test("the inline catalog uses the same JSDoc signatures", async () => {
+  test("the inline catalog line for the same tool stays single-line compact", () => {
     const instructions = runtime.instructions()
-    const github = (await search("list issues repository")).items.find(
-      ({ path }) => path === "tools.github.list_issues",
-    )!
-    const orders = (await search("look up order")).items.find(({ path }) => path === "tools.orders.lookup")!
-    expect(instructions).toContain(`  - ${github.signature} // List issues in a repository`)
-    expect(instructions).toContain(`  - ${orders.signature} // Look up an order`)
-    expect(instructions).toContain("/** Repository owner */")
-  })
-})
-
-describe("non-identifier tool paths", () => {
-  const resolveLibrary = Tool.make({
-    description: "Resolve a Context7 library ID",
-    input: {
-      type: "object",
-      properties: {
-        query: { type: "string" },
-        libraryName: { type: "string" },
-      },
-      required: ["query", "libraryName"],
-    } as const,
-    run: () => Effect.succeed("/reactjs/react.dev"),
-  })
-  const runtime = CodeMode.make({ tools: { context7: { "resolve-library-id": resolveLibrary } } })
-
-  test("inline catalog uses bracket notation for dashed tool names", () => {
-    const instructions = runtime.instructions()
-
     expect(instructions).toContain(
-      'tools.context7["resolve-library-id"](input: {\n  query: string,\n  libraryName: string,\n}): Promise<unknown>',
+      '  - tools.github.list_issues(input: { owner: string; after?: string; perPage?: number; labels?: Array<string>; state?: "open" | "closed" }): Promise<unknown> // List issues in a repository',
     )
-    expect(instructions).toContain("Do not infer or normalize tool names")
-    expect(instructions).toContain("bracket notation and quotes are part of the path")
-    expect(instructions).not.toContain("tools.context7.resolve-library-id")
-    expect(instructions).not.toContain("tools.context7.resolve_library_id")
-  })
-
-  test("search results return callable bracket-notation paths and signatures", async () => {
-    const result = await Effect.runPromise(
-      runtime.execute(`return await tools.$codemode.search({ query: "resolve library" })`),
+    expect(instructions).toContain(
+      "  - tools.orders.lookup(input: { id: string; verbose?: boolean }): Promise<{ status: string }> // Look up an order",
     )
-    expect(result.ok).toBe(true)
-    if (!result.ok) throw new Error("search failed")
-
-    const value = result.value as { items: Array<{ path: string; signature: string }> }
-    expect(value.items[0]?.path).toBe('tools.context7["resolve-library-id"]')
-    expect(value.items[0]?.signature).toContain('tools.context7["resolve-library-id"](input: {')
+    expect(instructions).not.toContain("/**")
   })
 })

packages/codemode/test/stdlib.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, test } from "bun:test"
-import { Effect, Schema } from "effect"
+import { Effect } from "effect"
 import { CodeMode, Tool } from "../src/index.js"
 
 // Standard-library value types: Date, RegExp, Map, Set. Programs use them as ordinary JS;
 // intra-sandbox checkpoints (Object.* helpers, spread, coercion inputs) preserve the live
 // values, while at the host boundary (final result, tool arguments, JSON.stringify) they
 // serialize exactly as JSON.stringify would: Date -> ISO string (invalid -> null),
-// URL -> href, and RegExp/Map/Set/URLSearchParams -> {}.
+// RegExp/Map/Set -> {}.
 const run = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} }))
 const value = async (code: string) => {
   const result = await run(code)
@@ -149,67 +149,6 @@ describe("RegExp", () => {
     expect(await value(`return "hi bob".replace(/b(o)b/, "[$1]")`)).toBe("hi [o]")
   })
 
-  test("function replacers receive captures, offsets, input, and named groups", async () => {
-    expect(
-      await value(`
-        const seen = []
-        const output = "a1b22".replace(/(\\d)(\\d)?/g, (match, first, second, offset, input) => {
-          seen.push([match, first, second === undefined, offset, input])
-          return Number(match) * 2
-        })
-        return { output, seen }
-      `),
-    ).toEqual({
-      output: "a2b44",
-      seen: [
-        ["1", "1", true, 1, "a1b22"],
-        ["22", "2", false, 3, "a1b22"],
-      ],
-    })
-    expect(
-      await value(`
-        return "red-blue".replace(
-          /(?<left>[a-z]+)-(?<right>[a-z]+)/,
-          (match, left, right, offset, input, groups) => groups.right + ":" + groups.left,
-        )
-      `),
-    ).toBe("blue:red")
-  })
-
-  test("function replacers support string searches, zero-length matches, and result coercion", async () => {
-    expect(await value(`return "banana".replace("na", (match, offset, input) => "[" + offset + "]")`)).toBe("ba[2]na")
-    expect(await value(`return "ab".replaceAll("", (match, offset) => offset)`)).toBe("0a1b2")
-    expect(await value(`return "😀".replaceAll(/(?:)/gu, (match, offset) => "[" + offset + "]")`)).toBe("[0]😀[2]")
-    expect(
-      await value(`return "123".replace(/\\d/g, (match) => match === "1" ? 7 : match === "2" ? null : { n: 3 })`),
-    ).toBe("7null[object Object]")
-  })
-
-  test("function replacers can await effectful tool calls", async () => {
-    const decorate = Tool.make({
-      description: "Decorate a string",
-      input: Schema.String,
-      output: Schema.String,
-      run: (input) => Effect.succeed(`[${input}]`),
-    })
-    const result = await Effect.runPromise(
-      CodeMode.execute({
-        tools: { host: { decorate } },
-        code: `return "a1b22".replace(/\\d+/g, async (match) => await tools.host.decorate(match))`,
-      }),
-    )
-    expect(result.ok && result.value).toBe("a[1]b[22]")
-
-    const missingAwait = await Effect.runPromise(
-      CodeMode.execute({
-        tools: { host: { decorate } },
-        code: `return "a1".replace(/\\d/, (match) => tools.host.decorate(match))`,
-      }),
-    )
-    expect(!missingAwait.ok && missingAwait.error.kind).toBe("InvalidDataValue")
-    expect(!missingAwait.ok && missingAwait.error.message).toContain("un-awaited Promise")
-  })
-
   test("replaceAll without the g flag is a catchable error", async () => {
     expect(await value(`try { "a".replaceAll(/a/, "b"); return "no" } catch { return "caught" }`)).toBe("caught")
   })
@@ -269,165 +208,6 @@ describe("RegExp", () => {
   })
 })
 
-describe("URL and URI helpers", () => {
-  test("encodes and decodes complete URIs and URI components", async () => {
-    expect(
-      await value(`
-        return [
-          encodeURI("https://example.test/a b?q=a/b"),
-          encodeURIComponent("a b/c?"),
-          decodeURI("https://example.test/a%20b?q=a/b"),
-          decodeURIComponent("a%20b%2Fc%3F"),
-          ["a b", "c/d"].map(encodeURIComponent),
-        ]
-      `),
-    ).toEqual([
-      "https://example.test/a%20b?q=a/b",
-      "a%20b%2Fc%3F",
-      "https://example.test/a b?q=a/b",
-      "a b/c?",
-      ["a%20b", "c%2Fd"],
-    ])
-    expect(
-      await value(`try { decodeURIComponent("%zz"); return false } catch (error) { return error instanceof URIError }`),
-    ).toBe(true)
-  })
-
-  test("resolves and mutates URLs with linked search parameters", async () => {
-    expect(
-      await value(`
-        const url = new URL("../users?id=old#top", "https://user:pass@example.com:8443/api/v1/")
-        url.pathname = "/items/a b"
-        url.searchParams.set("id", "a b")
-        url.searchParams.append("tag", "x/y")
-        url.hash = "part 1"
-        return {
-          href: url.href,
-          origin: url.origin,
-          host: url.host,
-          pathname: url.pathname,
-          search: url.search,
-          id: url.searchParams.get("id"),
-          string: String(url),
-          json: url.toJSON(),
-          instances: [
-            url instanceof URL,
-            url.searchParams instanceof URLSearchParams,
-            url.searchParams === url.searchParams,
-          ],
-        }
-      `),
-    ).toEqual({
-      href: "https://user:pass@example.com:8443/items/a%20b?id=a+b&tag=x%2Fy#part%201",
-      origin: "https://example.com:8443",
-      host: "example.com:8443",
-      pathname: "/items/a%20b",
-      search: "?id=a+b&tag=x%2Fy",
-      id: "a b",
-      string: "https://user:pass@example.com:8443/items/a%20b?id=a+b&tag=x%2Fy#part%201",
-      json: "https://user:pass@example.com:8443/items/a%20b?id=a+b&tag=x%2Fy#part%201",
-      instances: [true, true, true],
-    })
-  })
-
-  test("URLSearchParams supports records, pairs, mutation, callbacks, and materialization", async () => {
-    expect(
-      await value(`
-        const params = new URLSearchParams([["tag", "b"], ["tag", "a"], ["q", "a b"]])
-        const seen = []
-        params.forEach((value, key) => seen.push(key + "=" + value))
-        params.delete("tag", "b")
-        params.append("tag", "c")
-        params.sort()
-        return {
-          text: params.toString(),
-          size: params.size,
-          tags: params.getAll("tag"),
-          has: params.has("tag", "c"),
-          entries: Array.from(params),
-          object: Object.fromEntries(params),
-          record: new URLSearchParams({ page: 2, filter: "open" }).toString(),
-          seen,
-        }
-      `),
-    ).toEqual({
-      text: "q=a+b&tag=a&tag=c",
-      size: 3,
-      tags: ["a", "c"],
-      has: true,
-      entries: [
-        ["q", "a b"],
-        ["tag", "a"],
-        ["tag", "c"],
-      ],
-      object: { q: "a b", tag: "c" },
-      record: "page=2&filter=open",
-      seen: ["tag=b", "tag=a", "q=a b"],
-    })
-  })
-
-  test("URL parsing failures are catchable and values use native JSON forms", async () => {
-    expect(
-      await value(`
-        const parsed = URL.parse("/users", "https://example.test/api/")
-        let invalidIsTypeError = false
-        try { new URL("not relative without a base") } catch (error) { invalidIsTypeError = error instanceof TypeError }
-        return {
-          canParse: URL.canParse("/users", "https://example.test/api/"),
-          cannotParse: URL.canParse("not relative without a base"),
-          parsed: parsed.href,
-          invalidIsTypeError,
-          boundary: [new URL("https://example.test/a"), new URLSearchParams("q=one")],
-          json: JSON.stringify({ url: new URL("https://example.test/a"), params: new URLSearchParams("q=one") }),
-        }
-      `),
-    ).toEqual({
-      canParse: true,
-      cannotParse: false,
-      parsed: "https://example.test/users",
-      invalidIsTypeError: true,
-      boundary: ["https://example.test/a", {}],
-      json: '{"url":"https://example.test/a","params":{}}',
-    })
-  })
-
-  test("distinguishes omitted URL arguments from explicit undefined", async () => {
-    expect(
-      await value(`
-        function throwsTypeError(run) {
-          try { run(); return false } catch (error) { return error instanceof TypeError }
-        }
-        const params = new URLSearchParams()
-        const required = [
-          () => params.append(),
-          () => params.delete(),
-          () => params.get(),
-          () => params.getAll(),
-          () => params.has(),
-          () => params.set(),
-          () => params.forEach(),
-        ].map(throwsTypeError)
-        params.append(undefined, undefined)
-        return {
-          construct: throwsTypeError(() => new URL()),
-          canParse: throwsTypeError(() => URL.canParse()),
-          parse: throwsTypeError(() => URL.parse()),
-          explicitUndefined: new URL(undefined, "https://example.test/base/").href,
-          params: params.toString(),
-          required,
-        }
-      `),
-    ).toEqual({
-      construct: true,
-      canParse: true,
-      parse: true,
-      explicitUndefined: "https://example.test/base/undefined",
-      params: "undefined=undefined",
-      required: [true, true, true, true, true, true, true],
-    })
-  })
-})
-
 describe("Map", () => {
   test("get/set/has/size with chaining", async () => {
     expect(