@zackbart/connecta 0.10.6 → 0.11.0

package/documentation/connectors.md

@@ -33,7 +33,7 @@ Connecta deliberately sits between protocol generations
   [#206](https://github.com/zackbart/connecta/issues/206).
 - **Multi-round-trip results:** a downstream `input_required` result becomes a
   non-retryable `input_required_unsupported` failure. `call_tool`, the
-  `execute_code` host bridge, and classic's `batch_call` all preserve the
+  `execute_code` host bridge and internal batch path both preserve the
   structured code. Relaying the
   opaque `requestState` is architecturally possible but gated until real hosts
   and downstreams adopt it.

package/documentation/meta-tools.md

@@ -4,26 +4,20 @@ Connecta keeps one small tool surface in model context and resolves downstream
 tools behind it. `search_tools` finds addresses, the call tools enforce safety
 annotations, and `get_result` pages bounded results.
 
-## Which surface a deployment serves
+## The deployment surface
 
-The `executor` decides it, and there is nothing else to configure
-([#224](https://github.com/zackbart/connecta/issues/224)):
-
-| | `tools/list` | Discovery breadth and batching |
-| --- | --- | --- |
-| **executor configured** | seven: `execute_code`, `search_tools`, `call_tool`, `call_destructive_tool`, `authorize_connector`, `get_result`, `skills` | `connecta.search`, `connecta.describe`, `connecta.batch` inside a program |
-| **no executor** | nine: the above minus `execute_code`, plus `list_connectors`, `describe_tools`, `batch_call` | those three top-level tools |
+Every deployment requires an executor and `tools/list` is exactly seven:
+`execute_code`, `search_tools`, `call_tool`, `call_destructive_tool`,
+`authorize_connector`, `get_result`, and `skills`. Discovery breadth and
+batching live in `connecta.search`, `connecta.describe`, and `connecta.batch`
+inside a program ([#273](https://github.com/zackbart/connecta/issues/273)).
 
 Code-first is what a model sees. Four overlapping ways to reach one connector
 became two: `search_tools` then `call_tool` for a single cold read — measurably
 cheaper direct than through a program — and `execute_code` for everything wider.
-The fold is worth 19.6% of the serialized tool definitions measured against the
-ten-tool shape an executor-backed deployment used to serve — 10,675B to 8,587B —
-and, more durably, one fewer routing decision a model makes before doing any
-work. Note which baseline that is: the executor-free nine serialize to 7,207B,
-so the seven-tool surface is *larger* than the row below it in that table. It
-buys the program with those bytes. The [guest API contract](./code-mode.md) is
-what a program is promised.
+The consolidation removed overlapping routing choices while preserving the
+cheaper direct path for one cold call. The [guest API contract](./code-mode.md)
+is what a program is promised.
 
 `execute_code` accepts optional `diagnostics: true` when a caller is measuring
 a workflow. It adds only compact request-local timing and serialized-size
@@ -31,20 +25,11 @@ aggregates; normal calls carry no diagnostics block or response-context cost.
 The measurements never contain program source, arguments, values, addresses,
 credentials, logs, or raw error text.
 
-Classic is the compatibility surface: what an executor-free deployment
-necessarily serves, since the program surface the fold depends on is not there.
-It is supported and tested, not an equal citizen in the docs. `surface:
-"classic"` beside an executor is the only override; it produces the ten-tool
-shape the [eval gate](../eval/code-first-gate/README.md)'s *incremental* arm
-measures. That gate's control arm is executor-free classic and needs no
-override.
-
 Nothing became unreachable. `connecta.describe` takes the same addresses and
-formats as `describe_tools`, `connecta.batch` runs the same 1–10 parallel
-read-only calls as `batch_call` and returns the same typed outcomes, and an
-unfiltered `connecta.search({})` browses every catalog a program can reach —
-the part of `list_connectors` a model used. Live connector probing was the rest
-of it, and that is an operator concern: the operator pages and `/health` own it.
+formats as the internal catalog service, `connecta.batch` runs 1–10 parallel
+read-only calls and returns typed outcomes, and an unfiltered
+`connecta.search({})` browses every catalog a program can reach. Live connector
+probing is an operator concern: the operator pages and `/health` own it.
 
 ## Discovery context
 
@@ -61,8 +46,8 @@ shape. Bounded plain-object schemas also expose `inputKeys`,
 list rather than repeating a large partial inventory. Matches carry declared
 behavior annotations. When
 that shape is sufficient, call the returned address directly. Reserve schema
-expansion — `connecta.describe` in a program, `describe_tools` on the classic
-surface — for a search without schemas, an ambiguous compact shape, or exact
+expansion through `connecta.describe` for a search without schemas, an
+ambiguous compact shape, or exact
 constraints that require `format: "json"`.
 
 Compact search is deliberately a routing view, not a second copy of connector
@@ -89,12 +74,11 @@ mode; they are not a duplicated Connecta object result. Newly stashed JSON and
 downstream content envelopes use compact serialization, so `get_result` byte
 offsets and totals refer to that exact compact text.
 
-A `call_tool` or `batch_call` truncation notice carries both the historical
-`resultId` and an exact
-`nextAction: { tool: "get_result", arguments: { id, offset: 0 } }`. The handle
-is therefore directly actionable without copying an identifier out of prose;
-re-calling with `fields` remains the smaller alternative when projection is
-possible. Program results and oversized discovery responses carry no such
+A `call_tool` truncation notice carries both the historical `resultId` and an
+exact `nextAction: { tool: "get_result", arguments: { id, offset: 0 } }`. The
+handle is therefore
+directly actionable without copying an identifier out of prose; re-calling with
+`fields` remains the smaller alternative when projection is possible. Program results and oversized discovery responses carry no such
 route — paging a program's return value is a refused shape, because a program
 can shrink anything before it returns.
 
@@ -186,7 +170,7 @@ read from the vault on the next call and needs no redeploy.
 Predictable local refusals carry structured recovery on both result modes.
 An unknown connector suggests an unscoped discovery query derived from the
 attempted tool name; an unknown tool scopes the same query to the connector that
-answered. The suggested route follows the caller's own surface: `tool:
+answered. The suggested route follows the route the caller took: `tool:
 "search_tools"` for a top-level call, `function: "connecta.search"` with the same
 arguments when the miss happened inside `execute_code`, which has no way to call
 a tool. A read path that reaches an unannotated, write-capable, or destructive
@@ -197,9 +181,10 @@ That route echoes the caller's own arguments back only while they fit a
 512-byte budget, and then whole — never clipped. An error envelope is not
 size-guarded the way a result is, so an unbounded echo would let a large
 argument object produce a refusal many times the deployment's result cap, on
-both `call_tool` and the `batch_call` envelope. Over budget, `args` is absent
-and the `purpose` says to re-send what was just sent: the agent already holds
-its own arguments, and half of them would describe a call nobody made.
+both `call_tool` and calls a program routes through `connecta.call` or
+`connecta.batch`. Over budget, `args` is absent and the `purpose` says to
+re-send what was just sent: the agent already holds its own arguments, and half
+of them would describe a call nobody made.
 
 The address gets the same budget and the opposite rule: 512 bytes, clamped
 with a trailing `…` rather than dropped. It is caller-authored too — an
@@ -221,9 +206,11 @@ reason rather than as a reason to refuse the call.
 Activity carries an optional coarse `friction` class: `tool_not_found`,
 `schema_retry`, `destructive_reroute`, `auth_required`, or `result_too_large`.
 It is derived from the typed error code, except on the one call that has no
-error code to derive from: a `call_tool` result — or a `batch_call` child's —
-too large to return inline is friction for the agent while remaining
-`outcome: "success"`. That is the only source of `result_too_large` friction.
+error code to derive from: a result too large to return inline is friction for
+the agent while remaining `outcome: "success"`. That applies to a `call_tool`
+result, the only source of `result_too_large` friction. (Activity stored by
+older releases may still carry the retired `batch_call` source; nothing writes
+it today.)
 An oversized *discovery* response and an oversized program return are shaped
 differently and produce none, and an `errorCode` is written only when the call
 actually failed. The category adds no arguments, results, search text,

package/documentation/rich-output-design.md

@@ -20,13 +20,13 @@ program cannot "return less" of a screenshot — so any rich block a downstream
 tool produces dies at the exit guard, converted to a truncation envelope whose
 preview is the head of a base64 string, which is of use to no one.
 
-The asymmetry is already visible in the classic surface. `call_tool` forwards
+The asymmetry is already visible in the direct-call surface. `call_tool` forwards
 non-text downstream blocks to the client untouched when they fit the result cap
 (the fix for issue #43 made the guard measure every block, then pass them
 through in original order). And on the intake side, a host call **inside** a
 program is not size-capped at all: `unwrapMcpResult` hands mixed content
 through as a raw object, base64 and all. So today a downstream image survives
-the trip *into* the sandbox and survives the classic surface entirely — the one
+the trip *into* the sandbox and survives the explicit tool boundary — the one
 place it cannot survive is the exit of the surface connecta calls primary.
 
 ## The shape: `connecta.emit(block)`
@@ -103,8 +103,8 @@ uncapped) and emits it. The host attaches no attribution.
 **M7.** `emit` does not spend the host-call budget (`L4`). Its bounds are
 `M5`'s and only `M5`'s.
 
-**M8.** `ExecuteResult` is unchanged. No executor — QuickJS, Dynamic Worker,
-or third-party — needs modification, and the parity suite runs the same
+**M8.** `ExecuteResult` is unchanged. Neither QuickJS, Dynamic Worker, nor a
+third-party executor needs modification, and the parity suite runs the same
 emitting program through both vitest projects and asserts identical delivered
 content.
 

package/examples/node/README.md

@@ -32,8 +32,7 @@ value outside this local example.
 Keep this deployment small:
 
 - Edit `src/index.ts` to change connectors, auth, storage, and the public URL.
-- Keep `executor: quickJsExecutor()` unless you deliberately want the classic
-  compatibility surface.
+- Keep the required `executor: quickJsExecutor()` configuration.
 - Keep secrets in environment variables or an external secret store. Never put
   tokens in `src/index.ts`, connector guides, or committed JSON.
 - Add application code only when implementing a deliberate `api()` connector.

package/examples/node/src/index.ts

@@ -30,9 +30,7 @@ const connecta = createConnecta({
   auth: bearerToken(token, { subjectId: "operator" }),
   // Downstream OAuth callbacks use this deployment origin.
   publicUrl: `http://localhost:${port}`,
-  // Code mode: QuickJS runs model-written JS in a bounded disposable child.
-  // This line is also what selects the seven-tool code-first surface; remove it
-  // to serve the nine classic meta-tools instead.
+  // Required: QuickJS runs model-written JS in a bounded disposable child.
   executor: quickJsExecutor(),
   connectors: [
     api("time", {

package/examples/worker/README.md

@@ -2,9 +2,8 @@
 
 A deployable Worker that aggregates a downstream remote MCP and an in-code HTTP
 API connector, guarded by Clerk OAuth *and* a static bearer token, with state in
-a KV namespace. One Wrangler binding turns on paid code mode, which is also what
-selects the seven-tool code-first surface; the checked-in configuration deploys
-without it, serving the nine classic meta-tools on the Workers Free plan.
+a KV namespace. Its required Worker Loader binding backs the seven-tool surface
+and requires the Workers Paid plan.
 
 This is also the **starting template for a deployment**: a real deployment
 should be its own repository that pins an exact `@zackbart/connecta` version and
@@ -56,21 +55,17 @@ Connections. Credentials is at `/credentials`, named MCP access tokens are at
 
 ## Code mode
 
-Code mode is a deploy-time opt-in because its Dynamic Worker sandbox requires
-the [Workers Paid plan](https://developers.cloudflare.com/dynamic-workers/pricing/).
-The Worker Loader binding is the switch; no TypeScript change or separate
-environment variable is needed. Add this block to `wrangler.jsonc` (and a comma
-after the preceding property):
+The Dynamic Worker sandbox requires the
+[Workers Paid plan](https://developers.cloudflare.com/dynamic-workers/pricing/).
+The required Worker Loader binding is checked into `wrangler.jsonc`:
 
 ```jsonc
 "worker_loaders": [{ "binding": "LOADER" }]
 ```
 
-`src/index.ts` detects `env.LOADER`, constructs `DynamicWorkerExecutor`, and
-serves the seven-tool code-first surface. Leave the binding absent — as it is in
-the checked-in config — to deploy the same source on the Workers Free plan with
-the nine classic meta-tools. A deployment copied into its own repository must
-also install the executor package before enabling the binding:
+`src/index.ts` constructs `DynamicWorkerExecutor` from `env.LOADER` and serves
+the seven-tool surface. A deployment copied into its own repository must also
+install the executor package:
 
 ```sh
 npm install @cloudflare/codemode

package/examples/worker/src/index.ts

@@ -3,8 +3,8 @@
  *
  * One MCP endpoint aggregating a downstream remote MCP and an HTTP API, guarded
  * by Clerk OAuth *and* a static bearer token, with OAuth/cache state in a KV
- * namespace. Add the optional Worker Loader binding in wrangler.jsonc for the
- * seven-tool code-first surface; without it this serves the nine classic tools.
+ * namespace. The required Worker Loader binding in wrangler.jsonc backs the
+ * seven-tool surface.
  *
  * Setup (this example has no package.json of its own — it self-references the
  * installed `@zackbart/connecta` package):
@@ -19,8 +19,7 @@
  *      and CLERK_PUBLISHABLE_KEY + PUBLIC_URL as plain vars in wrangler.jsonc.
  *   4. Enable Dynamic Client Registration in the Clerk dashboard
  *        (OAuth Applications -> DCR toggle) so Claude/Cursor can self-register.
- *   5. Optional paid code mode: add the documented `worker_loaders` binding to
- *      wrangler.jsonc. Binding presence enables execute_code automatically.
+ *   5. Use the Workers Paid plan required by the `worker_loaders` binding.
  *   6. `wrangler deploy` from this folder (examples/worker), where wrangler.jsonc
  *      lives. Point your MCP client at `<PUBLIC_URL>/mcp`.
  */
@@ -46,23 +45,16 @@ interface Env {
   PUBLIC_URL: string;
   /**
    * Worker Loader binding (wrangler.jsonc `worker_loaders`) powering
-   * execute_code and, with it, the code-first surface. Dynamic Workers require
-   * the Workers Paid plan; leave the binding absent for the nine classic
-   * meta-tools on either plan.
+   * execute_code. Dynamic Workers require the Workers Paid plan.
    */
-  LOADER?: WorkerLoader;
+  LOADER: WorkerLoader;
 }
 
 function build(env: Env) {
   return createConnecta({
     publicUrl: env.PUBLIC_URL,
     storage: cloudflareKvStorage(env.CONNECTA_KV),
-    // Binding-as-switch: adding worker_loaders in wrangler.jsonc enables code
-    // mode and the seven-tool code-first surface with it; leaving it absent
-    // keeps this deployment free-tier compatible on the classic surface.
-    ...(env.LOADER
-      ? { executor: new DynamicWorkerExecutor({ loader: env.LOADER }) }
-      : {}),
+    executor: new DynamicWorkerExecutor({ loader: env.LOADER }),
     auth: [
       // Multiple credentials may identify callers in one deployment. Every
       // admitted caller reaches this deployment's deliberate connector set.

package/examples/worker/wrangler.jsonc

@@ -16,11 +16,8 @@
   // Create with `wrangler kv namespace create CONNECTA_KV` and paste the id.
   "kv_namespaces": [
     { "binding": "CONNECTA_KV", "id": "replace-with-kv-namespace-id" }
-  ]
+  ],
 
-  // Optional paid code mode: add a comma above, then uncomment this binding.
-  // Its presence is the entire switch — src/index.ts detects env.LOADER and
-  // serves the seven-tool code-first surface. Leave it absent for a free-tier
-  // deployment with the nine classic meta-tools.
-  // "worker_loaders": [{ "binding": "LOADER" }]
+  // Required by execute_code; Dynamic Workers use the Workers Paid plan.
+  "worker_loaders": [{ "binding": "LOADER" }]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zackbart/connecta",
-  "version": "0.10.6",
+  "version": "0.11.0",
   "type": "module",
   "sideEffects": false,
   "description": "One MCP to rule them all — a single MCP endpoint aggregating many downstream connectors behind a code-first surface of seven meta-tools.",

package/src/activity.ts

@@ -23,6 +23,11 @@ const MAX_ACTIVITY_ADDRESS_BYTES = MAX_ACTIVITY_NAME_BYTES * 2 + 1;
 export type ActivityCallSource =
   | "call_tool"
   | "call_destructive_tool"
+  // Read-only history. Nothing emits `batch_call` since issue #273 removed the
+  // tool, but activity storage is append-only: rows written by older
+  // deployments are still read back — the D1 example maps a stored row straight
+  // into this type — and an operator's timeline should not have to lie about
+  // where a call came from. Never widen this member back into a live source.
   | "batch_call"
   | "execute_code";
 

package/src/catalog-service.ts

@@ -48,23 +48,10 @@ const MAX_QUERY_ANALYSIS_TERM_LENGTH = 64;
 
 const encoder = new TextEncoder();
 
-/**
- * The tool a describe-path error should name when it tells a caller to retry.
- * This is the route the *caller* took, not the deployment's advertised surface:
- * a classic deployment with an executor serves `describe_tools` at top level
- * while every in-program describe still arrives through `connecta.describe`, so
- * one CatalogService cannot infer the answer from `surface` alone. Callers pass
- * the route they own.
- */
-export type DescribeRoute = "describe_tools" | "connecta.describe";
-
 /**
  * The discovery route a routing failure should send a caller back through. Same
- * rule as {@link DescribeRoute} — the route the *caller* took, not the
- * deployment's advertised surface — with one difference worth keeping the two
- * options separate for: `search_tools` exists on both advertised surfaces, so a
- * top-level handler never has to derive this one, while an in-program caller
- * still has to be told about `connecta.search` because it cannot call a tool.
+ * catalog logic serves both the top-level `search_tools` path and the
+ * in-program `connecta.search` path, so callers pass the route they own.
  */
 export type SearchRoute = "search_tools" | "connecta.search";
 
@@ -96,10 +83,7 @@ function discoverySearchLimit(value: unknown): number {
 }
 
 /** Normalize the single-address convenience form, then validate the bounded list. */
-function discoveryAddresses(
-  args: CatalogDescribeArgs,
-  describeRoute: DescribeRoute,
-): unknown[] {
+function discoveryAddresses(args: CatalogDescribeArgs): unknown[] {
   if (args.address !== undefined && args.addresses !== undefined) {
     throw new DiscoveryPolicyError(
       "invalid_args",
@@ -121,7 +105,7 @@ function discoveryAddresses(
   if (value.length > MAX_DESCRIBE_ADDRESSES) {
     throw new DiscoveryPolicyError(
       "invalid_args",
-      `addresses must contain at most ${MAX_DESCRIBE_ADDRESSES} entries. Split a larger list across ${describeRoute} calls.`,
+      `addresses must contain at most ${MAX_DESCRIBE_ADDRESSES} entries. Split a larger list across connecta.describe calls.`,
     );
   }
   return value;
@@ -327,7 +311,6 @@ export class CatalogService {
   readonly requestScope: object;
   private readonly probeTimeoutMs: number;
   private readonly concurrency: number;
-  private readonly describeRoute: DescribeRoute;
   private readonly searchRoute: SearchRoute;
   private readonly loaded = new Map<string, ToolDef[]>();
   private readonly loading = new Map<string, Promise<ToolDef[]>>();
@@ -339,8 +322,6 @@ export class CatalogService {
       requestScope?: object;
       probeTimeoutMs?: number;
       concurrency?: number;
-      /** The tool describe-path errors name. Default `describe_tools`. */
-      describeRoute?: DescribeRoute;
       /** The discovery route recovery records name. Default `search_tools`. */
       searchRoute?: SearchRoute;
     } = {},
@@ -349,7 +330,6 @@ export class CatalogService {
     this.probeTimeoutMs =
       normalizeTimeoutMs(options.probeTimeoutMs) ?? DEFAULT_PROBE_TIMEOUT_MS;
     this.concurrency = resolveDiscoveryConcurrency(options.concurrency);
-    this.describeRoute = options.describeRoute ?? "describe_tools";
     this.searchRoute = options.searchRoute ?? "search_tools";
   }
 
@@ -817,7 +797,7 @@ export class CatalogService {
   }
 
   async describe(args: CatalogDescribeArgs): Promise<CatalogDescription[]> {
-    const addresses = discoveryAddresses(args, this.describeRoute);
+    const addresses = discoveryAddresses(args);
     const format = args.format ?? "compact";
     const resolved = addresses.map((rawAddress) => {
       const address = String(rawAddress);
@@ -834,7 +814,7 @@ export class CatalogService {
       connectorIds,
       this.concurrency,
       (id) =>
-        this.loadForDiscovery(id, `${this.describeRoute} probe of "${id}"`),
+        this.loadForDiscovery(id, `connecta.describe probe of "${id}"`),
     );
     const catalogs = new Map<string, ToolDef[] | Error>();
     loaded.forEach((result, index) => {

package/src/connectors/api.ts

@@ -20,7 +20,7 @@ export interface ApiTool {
   outputSchema?: JsonSchema;
   /**
    * Standard MCP-style behavior hints. Only an explicit readOnlyHint: true
-   * admits the tool to call_tool, batch_call, and execute_code.
+   * admits the tool to call_tool and execute_code.
    */
   annotations?: ToolAnnotations;
   handler: (args: any, ctx: ConnectorContext) => Promise<unknown> | unknown;
@@ -32,7 +32,7 @@ export interface ApiOptions {
   description?: string;
   /**
    * Max inline result size (bytes) for this connector's tools before
-   * call_tool/batch_call truncate and stash the full text for get_result
+   * call_tool truncates and stashes the full text for get_result
    * paging. Overrides the deployment's `calls.maxResultBytes`; omit to inherit
    * it. Must be a whole number of bytes >= 1; anything else warns at startup
    * and is ignored.

package/src/connectors/remote-mcp.ts

@@ -38,7 +38,7 @@ export interface RemoteMcpOptions {
   description?: string;
   /**
    * Max inline result size (bytes) for this connector's tools before
-   * call_tool/batch_call truncate and stash the full text for get_result
+   * call_tool truncates and stashes the full text for get_result
    * paging. Overrides the deployment's `calls.maxResultBytes`; omit to inherit
    * it. Must be a whole number of bytes >= 1; anything else warns at startup
    * and is ignored.

package/src/errors.ts

@@ -221,7 +221,7 @@ export class ConnectorCallError extends Error {
   }
 }
 
-/** The `error` object surfaced in call_tool/batch_call value-mode results. */
+/** The `error` object surfaced in value-mode call results and connecta.batch entries. */
 export interface CallErrorDetails {
   code: string;
   message: string;
@@ -322,7 +322,7 @@ const RETRYABLE_MESSAGE_RE =
 const TIMEOUT_MESSAGE_RE = /timed out|timeout/i;
 
 /** Message-text fallback used when an error carries no typed classification. */
-export function messageLooksRetryable(message: string): boolean {
+function messageLooksRetryable(message: string): boolean {
   return RETRYABLE_MESSAGE_RE.test(message);
 }
 

package/src/execute.ts

@@ -24,7 +24,6 @@ import {
 } from "./invocation.js";
 import type { RegistryView } from "./registry.js";
 import type {
-  ConnectaSurface,
   Executor,
   ExecutorProvider,
   Logger,
@@ -425,12 +424,7 @@ export async function buildSandboxProviders(
   const requestScope = {};
   const catalog = new CatalogService(registry, baseUrl, {
     requestScope,
-    // Every describe reaching this catalog came from inside a program, on a
-    // code-first and a classic-with-executor deployment alike, so the retry
-    // advice names connecta.describe regardless of what this server advertises.
-    describeRoute: "connecta.describe",
-    // Same reasoning for the discovery route a routing failure hands back: the
-    // program that just missed an address cannot call search_tools.
+    // A program that just missed an address cannot call search_tools.
     searchRoute: "connecta.search",
     ...(limits.discoveryConcurrency !== undefined
       ? { concurrency: limits.discoveryConcurrency }
@@ -588,8 +582,8 @@ export async function buildSandboxProviders(
                     ),
                   };
                 } catch (err) {
-                  // Same failure shape batch_call reports: the message a program
-                  // can log, plus the typed details it must classify by. A
+                  // The failure shape connecta.batch reports: the message a
+                  // program can log, plus the typed details it must classify by. A
                   // thrown host error crosses the sandbox bridge as a bare
                   // message string in every executor, so this is the one place a
                   // program can tell a policy refusal from a transient failure.
@@ -857,7 +851,7 @@ export function createExecuteTool(
       // Executor bridges necessarily reduce thrown host errors to strings.
       // Match that terminal string back to the request-local typed failure so
       // an unhandled tool failure keeps the same structured contract as
-      // call_tool and batch_call. Failures caught by model code never reach
+      // call_tool. Failures caught by model code never reach
       // outcome.error and therefore remain under that code's control.
       //
       // An error the program let through unchanged matches exactly, and an
@@ -973,33 +967,12 @@ function discardedEmitsText(emitted: EmitCollector): string {
     : "";
 }
 
-/**
- * How the tool opens, and where a program's argument schemas come from. Both
- * differ by surface: on the classic surface `execute_code` is the tool of last
- * resort and its neighbours (`batch_call`, `describe_tools`) own the simpler
- * jobs, while on the code-first surface those tools are gone and the program is
- * where all of that work happens. Everything after these two phrases is
- * identical, so the shared body below has one source of truth.
- */
-const EXECUTE_ROUTING = {
-  classic:
-    "Use for dependent multi-step calls, loops, joins, branching, or reducing large results in a sandbox. Never use execute_code for search-only discovery or one downstream call: use search_tools, then call_tool when needed. For 2–10 independent calls use batch_call.",
-  "code-first":
-    "The primary surface. Use for discovery beyond one lookup, two or more calls, dependent steps, loops, joins, branching, or reducing large results before they reach the model — connecta.search and connecta.describe browse and expand catalogs in the run, and connecta.batch replaces a separate batch tool. The exception is a single call at an address already in hand: search_tools then one call_tool is cheaper than a program.",
-} as const;
-
-const EXECUTE_SCHEMA_SOURCE = {
-  classic: "describe_tools",
-  "code-first": "connecta.describe",
-} as const;
-
 const executeDescription = (
-  surface: ConnectaSurface,
   emitBudgets: { maxBytes: number; maxBlocks: number },
-) => `${EXECUTE_ROUTING[surface]} Only tools explicitly annotated readOnlyHint: true are available. Each run is limited to ${EXECUTE_MAX_HOST_CALLS} host calls; connecta.batch accepts at most ${EXECUTE_MAX_BATCH_CALLS}; each host call has a ${EXECUTE_HOST_CALL_TIMEOUT_MS / 1_000}-second deadline.
+) => `The primary surface. Use for discovery beyond one lookup, two or more calls, dependent steps, loops, joins, branching, or reducing large results before they reach the model — connecta.search and connecta.describe browse and expand catalogs in the run, and connecta.batch handles independent calls. The exception is a single call at an address already in hand: search_tools then one call_tool is cheaper than a program. Only tools explicitly annotated readOnlyHint: true are available. Each run is limited to ${EXECUTE_MAX_HOST_CALLS} host calls; connecta.batch accepts at most ${EXECUTE_MAX_BATCH_CALLS}; each host call has a ${EXECUTE_HOST_CALL_TIMEOUT_MS / 1_000}-second deadline.
 
 Write an async arrow function. It runs with NO network, filesystem, timers, or imports — the only capabilities are:
-- One global per connector: every address <connectorId>.<toolName> from search_tools is callable as <connectorId>.<toolName>(args) with a single args object matching the schema from ${EXECUTE_SCHEMA_SOURCE[surface]}. Names are sanitized to JS identifiers: characters outside [A-Za-z0-9_$] become "_" (e.g. my-service.get.thing → my_service.get_thing), leading digits get "_" prefixed, reserved words get "_" appended.
+- One global per connector: every address <connectorId>.<toolName> from search_tools is callable as <connectorId>.<toolName>(args) with a single args object matching the schema from connecta.describe. Names are sanitized to JS identifiers: characters outside [A-Za-z0-9_$] become "_" (e.g. my-service.get.thing → my_service.get_thing), leading digits get "_" prefixed, reserved words get "_" appended.
 - connecta.call(address, args) and connecta.batch(calls) — call raw addresses.
 - connecta.search(args), connecta.describe({ address: "<connectorId>.<toolName>" }), and connecta.describe({ addresses: [...] }) — load and inspect request-local catalogs on demand. Use safety: "readOnly" to avoid advertising calls this sandbox cannot execute; the filter changes results, not authority. Matches carrying schemas also list inputKeys, requiredInputKeys, and outputKeys — the same names the schema shows, ready to check against before building args. They are absent when a schema is not a plain object shape, so read the schema itself rather than assuming a missing list means no fields.
 - connecta.emit(block) — deliver rich MCP content alongside the JSON return: exactly { type: "text", text } or { type: "image" | "audio", data (base64), mimeType }, no other fields. Blocks are appended to the result on success only, spend no host calls, and are budgeted per run (${emitBudgets.maxBlocks} blocks, ${emitBudgets.maxBytes} serialized bytes); an over-budget or invalid emit throws catchably and accepts nothing.
@@ -1032,8 +1005,6 @@ export function registerExecuteTool(
     maxEmittedBytes?: number;
     /** Block-count budget for connecta.emit. Default 32. */
     maxEmittedBlocks?: number;
-    /** The advertised surface, which decides this tool's routing copy. */
-    surface?: ConnectaSurface;
   },
 ): void {
   // Resolved once so the description and the collector cannot disagree about
@@ -1065,7 +1036,7 @@ export function registerExecuteTool(
   server.registerTool(
     "execute_code",
     {
-      description: executeDescription(ctx.surface ?? "classic", emitBudgets),
+      description: executeDescription(emitBudgets),
       inputSchema: z.object({
         code: z
           .string()