@zackbart/connecta 0.22.3 → 0.23.0

package/dist/invocation.js

@@ -4,7 +4,7 @@ import { classifyCallError, ConnectorCallError, echoedCallArgs, framingError, }
 import { unwrapMcpResult } from "./mcp-result.js";
 import { splitAddress } from "./registry.js";
 import { isExplicitlyReadOnly } from "./tool-safety.js";
-import { sleep, withDeadline } from "./timeout.js";
+import { withDeadline } from "./timeout.js";
 import { validateToolInput } from "./validate.js";
 function defined(values) {
     return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
@@ -18,40 +18,6 @@ async function timed(bucket, fn) {
         bucket(Date.now() - started);
     }
 }
-/**
- * The longest the engine will park a synchronous inbound request in *waiting
- * alone*. The engine already treats ~15 s as the outer bound of one reasonable
- * connector call (EXECUTE_HOST_CALL_TIMEOUT_MS), so sleeping for minutes trades
- * a fast, informative failure for a hung one. A connector-reported window this
- * long isn't truncated — it's declined (see `retryBackoffMs`) and reported
- * verbatim as `error.retryAfterMs`, so the agent, which can afford to wait,
- * decides when to re-issue.
- */
-export const MAX_RETRY_BACKOFF_MS = 10_000;
-/**
- * How long to wait before the next attempt, or `undefined` for "don't retry".
- *
- * A connector that read a `Retry-After` header knows the window exactly, so it
- * is honoured **exactly or not at all**: truncating an exponential *guess* is
- * harmless, but truncating a *known* window means deliberately retrying inside
- * a rate limit — the harm this channel exists to prevent. A window longer than
- * `MAX_RETRY_BACKOFF_MS` therefore declines the retry rather than shortening
- * it. (`retryAfterMs` is normalized non-negative, so `0` means "retry now".)
- * Connectors that report no window keep the historical exponential guess.
- *
- * Waits are per attempt, matching the per-attempt `timeoutMs` race in
- * `InvocationService.invoke`. Exported for direct testing.
- */
-export function retryBackoffMs(attempt, retryAfterMs) {
-    if (retryAfterMs === undefined) {
-        return Math.min(250 * 2 ** (attempt - 1), 1_000);
-    }
-    return retryAfterMs <= MAX_RETRY_BACKOFF_MS ? retryAfterMs : undefined;
-}
-function retrySafe(definition) {
-    return (definition.annotations?.readOnlyHint === true ||
-        definition.annotations?.idempotentHint === true);
-}
 function callerCancelledDetails() {
     return {
         code: "cancelled",
@@ -122,23 +88,10 @@ export class InvocationService {
         this.activity = activity;
     }
     async invoke(address, args, context) {
-        const options = defined({ signal: context.requestSignal });
-        return this.invokeWithResolution(address, args, context, () => this.catalog.resolveTool(address, options));
-    }
-    /**
-     * Code-mode namespace dispatch preserves JavaScript-safe tool aliases while
-     * still feeding the resolved catalog entry through the one invocation path.
-     */
-    async invokeToolAlias(connectorId, toolAlias, aliasFor, args, context) {
-        const options = defined({ signal: context.requestSignal });
-        return this.invokeWithResolution(`${connectorId}.${toolAlias}`, args, context, () => this.catalog.resolveToolAlias(connectorId, toolAlias, aliasFor, options));
-    }
-    async invokeWithResolution(address, args, context, resolve) {
         const started = Date.now();
         let catalogMs = 0;
         let admissionMs = 0;
         let connectorMs = 0;
-        let backoffMs = 0;
         let resultProcessingMs = 0;
         let attempts = 0;
         let resolved;
@@ -151,7 +104,6 @@ export class InvocationService {
             catalogMs,
             admissionMs,
             connectorMs,
-            backoffMs,
             resultProcessingMs,
             totalMs: Date.now() - started,
         });
@@ -248,7 +200,7 @@ export class InvocationService {
                 error: details,
             };
         };
-        const resolution = await resolve();
+        const resolution = await this.catalog.resolveTool(address, defined({ signal: context.requestSignal }));
         catalogMs += resolution.catalogMs;
         if (!resolution.ok) {
             if (resolution.connector && resolution.toolName) {
@@ -290,80 +242,61 @@ export class InvocationService {
                 ? error.details
                 : classifyCallError(error));
         }
-        const maxRetries = Math.min(2, Math.max(0, Math.trunc(context.maxRetries ?? 0)));
         let result;
         let observedResult;
-        while (true) {
-            attempts++;
-            let permit;
-            let attemptError;
-            let attemptFailed = false;
-            try {
-                permit = await timed((elapsed) => { admissionMs += elapsed; }, () => this.registry.admitCall(resolved.connector.id, {
-                    toolName: resolved.toolName,
-                    args: args ?? {},
-                    ...defined({ signal: context.requestSignal }),
-                }));
-                const raw = await timed((elapsed) => { connectorMs += elapsed; }, () => {
-                    const call = (callSignal) => {
-                        const connectorContext = this.registry.contextFor(resolved.connector.id, this.catalog.baseUrl, this.catalog.requestScope, defined({ signal: callSignal, timeoutMs: context.timeoutMs }));
-                        if (resolved.connector.credential &&
-                            !connectorContext.credential) {
-                            throw new ConnectorCallError("auth_required", "Operator-managed credential storage is not configured. Call " +
-                                `authorize_connector({ connector: "${resolved.connector.id}" }).`);
-                        }
-                        // Cancellation can arrive during admission or context construction.
-                        if (callSignal?.aborted)
-                            throw callSignal.reason;
-                        return resolved.connector.callTool(resolved.toolName, args ?? {}, connectorContext);
-                    };
-                    if (!context.timeoutMs && !context.requestSignal)
-                        return call();
-                    return withDeadline(call, {
-                        ...defined({
-                            timeoutMs: context.timeoutMs,
-                            signal: context.requestSignal,
-                        }),
-                        timeoutError: new ConnectorCallError("timeout", `Tool call timed out after ${context.timeoutMs}ms`),
-                    });
-                });
-                // isError is checked here for BOTH result shapes so every adapter
-                // reports the same downstream-failure wording, and the throw lands
-                // inside the attempt where it stays retry-eligible and feeds health.
-                assertRawMcpSuccess(resolved.connector.kind, raw);
-                observedResult = unwrapMcpResult(resolved.connector.kind, raw);
-                result = context.unwrapResult ? observedResult : raw;
-            }
-            catch (error) {
-                attemptFailed = true;
-                attemptError = error;
-            }
-            finally {
-                permit?.release();
-            }
-            if (attemptFailed) {
-                const callerCancelled = isCallerCancellation(attemptError, context.requestSignal);
-                const details = callerCancelled
-                    ? callerCancelledDetails()
-                    : classifyCallError(attemptError);
-                if (!callerCancelled &&
-                    attempts <= maxRetries &&
-                    retrySafe(resolved.definition) &&
-                    details.retryable) {
-                    const wait = retryBackoffMs(attempts, details.retryAfterMs);
-                    if (wait !== undefined) {
-                        const completed = await timed((elapsed) => { backoffMs += elapsed; }, () => sleep(wait, context.requestSignal));
-                        if (!completed)
-                            return failed(callerCancelledDetails());
-                        continue;
+        attempts = 1;
+        let permit;
+        let attemptError;
+        let attemptFailed = false;
+        try {
+            permit = await timed((elapsed) => { admissionMs += elapsed; }, () => this.registry.admitCall(resolved.connector.id, {
+                toolName: resolved.toolName,
+                args: args ?? {},
+                ...defined({ signal: context.requestSignal }),
+            }));
+            const raw = await timed((elapsed) => { connectorMs += elapsed; }, () => {
+                const call = (callSignal) => {
+                    const connectorContext = this.registry.contextFor(resolved.connector.id, this.catalog.baseUrl, this.catalog.requestScope, defined({ signal: callSignal, timeoutMs: context.timeoutMs }));
+                    if (resolved.connector.credential &&
+                        !connectorContext.credential) {
+                        throw new ConnectorCallError("auth_required", "Operator-managed credential storage is not configured. Call " +
+                            `authorize_connector({ connector: "${resolved.connector.id}" }).`);
                     }
-                    // The reported window is longer than the engine will park a
-                    // synchronous request for. Fall through to failure with
-                    // retryAfterMs reported verbatim so the agent can re-issue.
-                }
-                return failed(details);
-            }
-            break;
+                    // Cancellation can arrive during admission or context construction.
+                    if (callSignal?.aborted)
+                        throw callSignal.reason;
+                    return resolved.connector.callTool(resolved.toolName, args ?? {}, connectorContext);
+                };
+                if (!context.timeoutMs && !context.requestSignal)
+                    return call();
+                return withDeadline(call, {
+                    ...defined({
+                        timeoutMs: context.timeoutMs,
+                        signal: context.requestSignal,
+                    }),
+                    timeoutError: new ConnectorCallError("timeout", `Tool call timed out after ${context.timeoutMs}ms`),
+                });
+            });
+            // isError is checked here for BOTH result shapes so every adapter
+            // reports the same downstream-failure wording, and the throw lands
+            // inside the attempt where it feeds health.
+            assertRawMcpSuccess(resolved.connector.kind, raw);
+            observedResult = unwrapMcpResult(resolved.connector.kind, raw);
+            result = context.unwrapResult ? observedResult : raw;
+        }
+        catch (error) {
+            attemptFailed = true;
+            attemptError = error;
+        }
+        finally {
+            permit?.release();
+        }
+        if (attemptFailed) {
+            const callerCancelled = isCallerCancellation(attemptError, context.requestSignal);
+            const details = callerCancelled
+                ? callerCancelledDetails()
+                : classifyCallError(attemptError);
+            return failed(details);
         }
         try {
             const value = await timed((elapsed) => { resultProcessingMs += elapsed; }, async () => {

package/dist/meta-tools.d.ts

@@ -2,9 +2,8 @@ import type { McpServer } from "@modelcontextprotocol/server";
 import type { ActivityRequestContext } from "./activity.js";
 import { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_SEARCH_LIMIT } from "./catalog-service.js";
 import type { DeferredWork } from "./connector-scope.js";
-import { MAX_RETRY_BACKOFF_MS, retryBackoffMs } from "./invocation.js";
 import { type RegistryView } from "./registry.js";
-export { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_RETRY_BACKOFF_MS, MAX_SEARCH_LIMIT, retryBackoffMs, };
+export { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_SEARCH_LIMIT, };
 interface TextContent {
     type: "text";
     text: string;
@@ -48,8 +47,6 @@ export interface CallArgs {
     args?: Record<string, unknown>;
     resultMode?: ResultMode;
     timeoutMs?: number;
-    /** Retries after the first attempt; honored only for safely annotated tools. */
-    maxRetries?: number;
     /** Include connector/catalog/result-processing timing segments. */
     diagnostics?: boolean;
 }
@@ -112,8 +109,8 @@ export declare function createMetaTools(registry: RegistryView, baseUrl: string,
 /**
  * Register the six explicit meta-tools onto an McpServer instance.
  * `registerExecuteTool` adds the seventh, `execute_code`. Broad discovery and
- * multi-call work is reached through `connecta.search` / `connecta.describe` /
- * `connecta.batch` inside a program, which `execute_code` builds over the same
+ * multi-call work uses discovery and ordinary JavaScript promises inside a
+ * program, which `execute_code` builds over the same
  * `CatalogService` and `InvocationService` these handlers use — one shared
  * services layer, two adapters above it.
  */

package/dist/meta-tools.js

@@ -3,11 +3,11 @@ import { boundedDiscoveryText, CatalogService, DEFAULT_SEARCH_LIMIT, DiscoveryPo
 import { resolveDiscoveryConcurrency } from "./concurrency.js";
 import { msg } from "./errors.js";
 import { serializeResultText } from "./executor-result.js";
-import { InvocationService, MAX_RETRY_BACKOFF_MS, retryBackoffMs, } from "./invocation.js";
+import { InvocationService, } from "./invocation.js";
 import { isValidMaxResultBytes, MIN_MAX_RESULT_BYTES, resolveMaxResultBytes, } from "./registry.js";
 import { hasConnectorGuides, listSkills, resolveSkill, } from "./skills.js";
 import { DEFAULT_PROBE_TIMEOUT_MS, normalizeTimeoutMs, } from "./timeout.js";
-export { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_RETRY_BACKOFF_MS, MAX_SEARCH_LIMIT, retryBackoffMs, };
+export { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_SEARCH_LIMIT, };
 const RESULT_TTL_SECONDS = 900;
 const enc = new TextEncoder();
 const dec = new TextDecoder();
@@ -267,9 +267,6 @@ export function createMetaTools(registry, baseUrl, opts = {}) {
                 ? { allowDestructive: options.allowDestructive }
                 : {}),
             ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-            ...(call.maxRetries !== undefined
-                ? { maxRetries: call.maxRetries }
-                : {}),
             ...(opts.requestSignal !== undefined
                 ? { requestSignal: opts.requestSignal }
                 : {}),
@@ -568,14 +565,13 @@ const CALL_INPUT_SCHEMA = {
     args: z.record(z.string(), z.unknown()).optional(),
     resultMode: z.enum(["mcp", "value"]).optional(),
     timeoutMs: z.number().int().positive().optional(),
-    maxRetries: z.number().int().min(0).max(2).optional(),
     diagnostics: z.boolean().optional(),
 };
 /**
  * Register the six explicit meta-tools onto an McpServer instance.
  * `registerExecuteTool` adds the seventh, `execute_code`. Broad discovery and
- * multi-call work is reached through `connecta.search` / `connecta.describe` /
- * `connecta.batch` inside a program, which `execute_code` builds over the same
+ * multi-call work uses discovery and ordinary JavaScript promises inside a
+ * program, which `execute_code` builds over the same
  * `CatalogService` and `InvocationService` these handlers use — one shared
  * services layer, two adapters above it.
  */
@@ -592,7 +588,6 @@ export function registerMetaTools(server, registry, ctx) {
         description: describedFor(registry, SKILLS_DESC, "skills"),
         inputSchema: z.object({ name: z.string().optional() }),
         annotations: READ_ONLY_LOCAL,
-        _meta: { ui: { visibility: ["model"] } },
     }, async (args) => mt.skills(args));
     server.registerTool("search_tools", {
         description: describedFor(registry, SEARCH_DESC, "search"),
@@ -608,20 +603,17 @@ export function registerMetaTools(server, registry, ctx) {
             includeSchemas: z.enum(["compact", "json"]).optional(),
         }),
         annotations: READ_ONLY_REMOTE,
-        _meta: { ui: { visibility: ["model"] } },
     }, async (args) => mt.searchTools(args));
     server.registerTool("call_tool", {
         description: CALL_DESC,
-        inputSchema: z.object(CALL_INPUT_SCHEMA),
+        inputSchema: z.strictObject(CALL_INPUT_SCHEMA),
         // call_tool admits only tools that are themselves explicitly read-only;
         // anything else is refused and routed to call_destructive_tool.
         annotations: READ_ONLY_REMOTE,
-        // Omission defaults to model + app. Display-only views may call no tool.
-        _meta: { ui: { visibility: ["model"] } },
     }, async (args) => mt.callTool(args));
     server.registerTool("call_destructive_tool", {
         description: describedFor(registry, CALL_DESTRUCTIVE_DESC, "destructive"),
-        inputSchema: z.object({
+        inputSchema: z.strictObject({
             ...CALL_INPUT_SCHEMA,
             // Bounded above, but with no lower bound: a model that sends `""` or
             // whitespace has written no reason, and failing an entire consequential
@@ -634,7 +626,6 @@ export function registerMetaTools(server, registry, ctx) {
             readOnlyHint: false,
             openWorldHint: true,
         },
-        _meta: { ui: { visibility: ["model"] } },
     }, async (args) => {
         // `reason` is the host's to display and connecta's to keep out of the
         // downstream call, so this destructuring is the whole of its handling:
@@ -657,7 +648,6 @@ export function registerMetaTools(server, registry, ctx) {
             destructiveHint: false,
             openWorldHint: true,
         },
-        _meta: { ui: { visibility: ["model"] } },
     }, async (args) => mt.authorizeConnector(args));
     server.registerTool("get_result", {
         description: GET_RESULT_DESC,
@@ -671,6 +661,5 @@ export function registerMetaTools(server, registry, ctx) {
             maxBytes: z.number().int().min(MIN_MAX_RESULT_BYTES).optional(),
         }),
         annotations: READ_ONLY_LOCAL,
-        _meta: { ui: { visibility: ["model"] } },
     }, async (args) => mt.getResult(args));
 }

package/dist/registry.js

@@ -131,6 +131,10 @@ export class Registry {
         this.persistToolCatalog = opts.persistToolCatalog ?? true;
         this.maxResultBytes = resolveMaxResultBytes(opts.maxResultBytes, DEFAULT_MAX_RESULT_BYTES);
         for (const c of connectors) {
+            if ("handleRequest" in c) {
+                throw new Error(`Connector "${c.id}" declares removed handleRequest. ` +
+                    "Move custom HTTP routes into the deployment's fetch handler.");
+            }
             if (!ID_RE.test(c.id)) {
                 throw new Error(`Invalid connector id "${c.id}": must match ${ID_RE.source}`);
             }

package/dist/routes/mcp.js

@@ -1,5 +1,4 @@
 import { createMcpHandler, isLegacyRequest, McpServer, WebStandardStreamableHTTPServerTransport, } from "@modelcontextprotocol/server";
-import { MCP_APPS_EXTENSION, PROGRAM_UI_MIME_TYPE, PROGRAM_UI_RESOURCE_URI, PROGRAM_UI_SHELL_HTML, } from "../apps-shell.js";
 import { registerExecuteTool } from "../execute.js";
 import { ExecutorAdmissionError, } from "../executor-admission.js";
 import { registerMetaTools } from "../meta-tools.js";
@@ -149,56 +148,10 @@ function toolkitRetired(logger) {
         },
     });
 }
-/**
- * U5: one static template, served by a handler that answers exactly one URI
- * and fails on every other. Registering it is also what declares the
- * `resources` capability — which is why `resources/list` has to answer, and
- * why it answers with nothing. That is the Apps spec's permitted omission of
- * UI-only resources from listing, taken exactly: the capability stays honest
- * because the method answers, and nothing downstream is ever listed or
- * aggregated. Widening this handler to proxy downstream templates is a
- * decision (see the design record), not a diff.
- */
-function registerProgramUiResource(server) {
-    server.registerResource("connecta-program-ui", PROGRAM_UI_RESOURCE_URI, {
-        title: "connecta program view",
-        description: "The MCP Apps shell that renders HTML an execute_code program handed connecta.ui.",
-        mimeType: PROGRAM_UI_MIME_TYPE,
-    }, (uri) => ({
-        contents: [
-            {
-                uri: uri.href,
-                mimeType: PROGRAM_UI_MIME_TYPE,
-                text: PROGRAM_UI_SHELL_HTML,
-            },
-        ],
-    }));
-    // The SDK's generated listing would advertise the template it just
-    // registered. Replace it rather than accept that: the URI reaches the host
-    // through tool metadata, so the listing has nothing to carry.
-    server.server.setRequestHandler("resources/list", () => ({ resources: [] }));
-}
 async function serveMcp(request, opts, baseUrl, actor, registry, runtimeContext) {
     const createServer = () => {
         const server = new McpServer(opts.serverInfo, {
             instructions: instructionsFor(),
-            // U11: the Apps extension must be explicitly negotiated, and a
-            // conforming client acts on an extension only when both sides declare
-            // it — without this line no host reads execute_code's _meta.ui, no host
-            // fetches the shell, and the whole design is inert. This is the one
-            // extension connecta advertises; the versioned extensions framework
-            // stays declined as a general surface (https://github.com/zackbart/connecta/blob/main/records/mcp-2026-07-28.md).
-            capabilities: {
-                extensions: {
-                    [MCP_APPS_EXTENSION]: { mimeTypes: [PROGRAM_UI_MIME_TYPE] },
-                },
-                // Registering the shell below declares `resources` on its own, but it
-                // would default `listChanged` to true. Connecta serves one build-time
-                // template and never sends a list_changed notification, so say so:
-                // a client that subscribes on the strength of that flag would wait
-                // forever for an event this server has no way to produce.
-                resources: { listChanged: false },
-            },
             cacheHints: {
                 "tools/list": {
                     ttlMs: 3_600_000,
@@ -206,7 +159,6 @@ async function serveMcp(request, opts, baseUrl, actor, registry, runtimeContext)
                 },
             },
         });
-        registerProgramUiResource(server);
         const activity = opts.activity
             ? {
                 sink: opts.activity,

package/dist/server.d.ts

@@ -4,7 +4,6 @@ export type { ServerOptions } from "./routes/shared.js";
  * Build the Web-standard fetch handler.
  *
  * Route ordering is the contract: private mutation routes precede wildcard
- * OPTIONS, every built-in precedes connector-owned routes, and the security
- * wrapper is applied to every response.
+ * OPTIONS, and the security wrapper is applied to every response, including 404s.
  */
 export declare function createFetchHandler(opts: ServerOptions): (request: Request, runtimeContext?: RuntimeExecutionContext) => Promise<Response>;

package/dist/server.js

@@ -10,8 +10,7 @@ import { routeUi } from "./routes/ui.js";
  * Build the Web-standard fetch handler.
  *
  * Route ordering is the contract: private mutation routes precede wildcard
- * OPTIONS, every built-in precedes connector-owned routes, and the security
- * wrapper is applied to every response.
+ * OPTIONS, and the security wrapper is applied to every response, including 404s.
  */
 export function createFetchHandler(opts) {
     const { auth, publicUrl, registry } = opts;
@@ -147,23 +146,6 @@ export function createFetchHandler(opts) {
             const mcp = await routeMcp(context);
             if (mcp)
                 return mcp;
-            // Connector-owned public routes, dispatched last: a connector can add a
-            // route but never shadow one of connecta's own. A throw here is the
-            // connector's bug, not a missing route, so it surfaces as 500 rather
-            // than falling through to 404.
-            for (const connector of registry.listConnectors()) {
-                if (!connector.handleRequest)
-                    continue;
-                try {
-                    const response = await connector.handleRequest(request, registry.contextFor(connector.id, baseUrl));
-                    if (response)
-                        return response;
-                }
-                catch (error) {
-                    opts.logger.error(`[connecta] connector "${connector.id}" handleRequest failed`, error);
-                    return new Response("Internal Server Error", { status: 500 });
-                }
-            }
             return new Response("Not Found", { status: 404 });
         };
         return withSecurityHeaders(await route(), url, path);

package/dist/skills.d.ts

@@ -1,5 +1,5 @@
 import type { Connector } from "./types.js";
-export declare const CONNECTA_INSTRUCTIONS = "Choose a route before discovery. A known-address read needs only call_tool. Unknown-address read-only work starts with one execute_code program that discovers, calls, and returns the answer; use the same route for reduction, multiple or dependent calls, loops, joins, or branches. Only readOnlyHint: true tools run there. Keep catalog inspection and unannotated, write-capable, or destructive work top level: search_tools then call_destructive_tool when a call is needed. After auth_required use authorize_connector. After a truncated direct result use get_result. connecta.ui(html) exists only inside execute_code, not in connector search; return the same summary data the HTML renders. Guidance is on demand: fetch skills({ name: \"usage\" }) only when these instructions and the tool description are insufficient or a run needs repair.";
+export declare const CONNECTA_INSTRUCTIONS = "Choose a route before discovery. A known-address read needs only call_tool. Unknown-address read-only work starts with execute_code to discover, call, and return the answer; use the same route for reduction, multiple or dependent calls, loops, joins, or branches. Keep discovery and calls together when schemas suffice; do not return catalog matches alone. Inspect unfamiliar result shapes with a small sample before proceeding. Only readOnlyHint: true tools run there. Keep catalog inspection and unannotated, write-capable, or destructive work top level: search_tools then call_destructive_tool when a call is needed. After auth_required use authorize_connector. After a truncated direct result use get_result. Guidance is on demand: fetch skills({ name: \"usage\" }) only when these instructions and the tool description are insufficient or a run needs repair.";
 /** Shared Connecta routing guidance, byte-identical across deployments. */
 export declare const USAGE_SKILL: string;
 /** The always-loaded MCP `instructions` string. */