@zackbart/connecta 0.37.0 → 0.38.0

package/dist/d1.d.ts

@@ -38,93 +38,4 @@ export declare function d1Storage(db: D1DatabaseBinding): KVStorage;
  * write prunes a bounded batch of rows older than `retentionDays`.
  */
 export declare function d1ActivityStore(db: D1DatabaseBinding, options?: D1ActivityOptions): ActivityStore;
-/**
- * The part of a Workers KV binding `copyKvToD1` reads. Structural, like
- * `D1DatabaseBinding`; a Worker's `KVNamespace` satisfies it.
- */
-export interface KVNamespaceBinding {
-    list(options?: {
-        limit?: number;
-        cursor?: string | null;
-    }): Promise<{
-        keys: readonly {
-            name: string;
-            expiration?: number;
-        }[];
-        list_complete: boolean;
-        cursor?: string;
-    }>;
-    get(key: string, type: "text"): Promise<string | null>;
-}
-export interface KvToD1CopyOptions {
-    /** The source KV namespace id. Resume tokens are bound to this identity. */
-    source: string;
-    /** Resume against the same source and database within seven days. */
-    cursor?: string;
-    /** Explicit families whose conflicting D1 rows the operator judged stale. */
-    overwriteFamilies?: readonly string[];
-    /** Compare value hashes and absolute expiries without copying entries. */
-    verify?: boolean;
-    /** Override the cutover guard only after assessing stale KV state. */
-    allowStale?: boolean;
-    /** Keys read per call. Default 500; use a smaller budget for large rows. */
-    maxKeys?: number;
-}
-/** What a copy did with one family's keys. */
-export interface KvToD1Counts {
-    /** Written where D1 held no live entry. */
-    copied: number;
-    /** D1 already held the same value. */
-    unchanged: number;
-    /** D1 held a different value or expiry and kept it. */
-    conflicts: number;
-    /** D1 held a different value or expiry, replaced under `overwriteFamilies`. */
-    overwritten: number;
-    /** Expired or deleted in Workers KV before it could be read. */
-    expired: number;
-    /** A key/value/row D1 cannot hold, left in Workers KV. */
-    invalid: number;
-    /** Exact value hash and expiry match during a verification pass. */
-    verified: number;
-    /** Missing or different value/expiry during a verification pass. */
-    mismatches: number;
-}
-export interface KvToD1CopyResult {
-    /** True once the whole namespace has been read. */
-    done: boolean;
-    /**
-     * Pass back as `options.cursor` to continue; absent when `done`. A random
-     * token: the Workers KV cursor it stands for stays in D1, because that
-     * cursor can spell the last key listed.
-     */
-    cursor?: string;
-    /**
-     * Counts by key family (`src/storage/keys.ts`), plus `connector-owned` and
-     * `unclassified`. Never a key or a value.
-     */
-    families: Record<string, KvToD1Counts>;
-}
-/**
- * A copy that stopped. The message is fixed wording that names a family at
- * most, never a key or value, and the binding's own error is not attached:
- * KV and D1 errors can quote either. Entries before `cursor` are copied;
- * rerunning from it is safe while the maintenance window still holds.
- */
-export declare class KvToD1CopyError extends Error {
-    /** Resume point; absent means start over, which is also safe. */
-    readonly cursor: string | undefined;
-    readonly name = "KvToD1CopyError";
-    constructor(message: string, 
-    /** Resume point; absent means start over, which is also safe. */
-    cursor: string | undefined);
-}
-/** Mark cutover before reopening traffic. The marker stays in D1 permanently. */
-export declare function markKvToD1Live(db: D1DatabaseBinding, source: string): Promise<void>;
-/**
- * Copy live KV entries verbatim while all writers and traffic are stopped.
- * A live D1 row is kept unless its family is explicitly allowed to overwrite.
- * `verify` reads hashes and absolute expiries without changing copied entries.
- * Results contain counts only. Resume tokens are source-bound atomic claims.
- */
-export declare function copyKvToD1(kv: KVNamespaceBinding, db: D1DatabaseBinding, options: KvToD1CopyOptions): Promise<KvToD1CopyResult>;
 export {};

package/dist/d1.js

@@ -3,12 +3,8 @@
 // One D1 database holds everything: `d1Storage(db)` is the deployment's
 // `KVStorage`, and `d1ActivityStore(db)` its activity history. Both create
 // their tables on first use, so binding the database is the whole setup.
-// `copyKvToD1` moves a 0.28 deployment's Workers KV state into it once.
-import { runEdge } from "./runtime/run.js";
 import { d1Driver } from "./storage/d1-driver.js";
-import { copyKvToD1Effect, markKvToD1LiveEffect } from "./storage/d1-copy.js";
 import { sqlActivityStore, sqlStorage } from "./storage/sql.js";
-import { keepErrorName } from "./redaction-identity.js";
 /**
  * `KVStorage` over a D1 database, with the atomic `compareAndSet` every
  * subsystem relies on. The `connecta_kv` table is created on first use; a
@@ -25,33 +21,3 @@ export function d1Storage(db) {
 export function d1ActivityStore(db, options) {
     return sqlActivityStore(d1Driver(db), "d1", options);
 }
-/**
- * A copy that stopped. The message is fixed wording that names a family at
- * most, never a key or value, and the binding's own error is not attached:
- * KV and D1 errors can quote either. Entries before `cursor` are copied;
- * rerunning from it is safe while the maintenance window still holds.
- */
-export class KvToD1CopyError extends Error {
-    cursor;
-    name = "KvToD1CopyError";
-    constructor(message, 
-    /** Resume point; absent means start over, which is also safe. */
-    cursor) {
-        super(message);
-        this.cursor = cursor;
-    }
-}
-keepErrorName(KvToD1CopyError, "KvToD1CopyError");
-/** Mark cutover before reopening traffic. The marker stays in D1 permanently. */
-export function markKvToD1Live(db, source) {
-    return runEdge(markKvToD1LiveEffect(db, source));
-}
-/**
- * Copy live KV entries verbatim while all writers and traffic are stopped.
- * A live D1 row is kept unless its family is explicitly allowed to overwrite.
- * `verify` reads hashes and absolute expiries without changing copied entries.
- * Results contain counts only. Resume tokens are source-bound atomic claims.
- */
-export function copyKvToD1(kv, db, options) {
-    return runEdge(copyKvToD1Effect(kv, db, options));
-}

package/dist/downstream-input.js

@@ -1,3 +1,4 @@
+import { toolError } from "./tool-error.js";
 import { RequestScope, requestOwner } from "./runtime/request-scope.js";
 import { Effect } from "effect";
 import { upwardStep } from "./upward.js";
@@ -129,8 +130,7 @@ function failure(code, message, write = false) {
             writeOutcome: "unknown",
         }
         : { code, message, retryable: false };
-    const structuredContent = { ok: false, error };
-    return { content: [{ type: "text", text: JSON.stringify(structuredContent) }], structuredContent, isError: true };
+    return toolError(error, { ok: false });
 }
 /** MCP-only continuation coordination. No downstream prompt enters operator records. */
 export class DownstreamElicitation {

package/dist/execute.js

@@ -1,4 +1,4 @@
-import { authCall, authInvoke, authMethod } from "./auth/native.js";
+import { authCall, authFlow, authInvoke, authMethod } from "./auth/native.js";
 import { nativeRecovery } from "./native-recovery.js";
 import { GUEST_API_DECLARATION } from "./usage-guide.js";
 import { bindMcpClient } from "./mcp-client-context.js";
@@ -18,10 +18,11 @@ import { guestPrelude, programError, wrapGuestProgram } from "./guest-runtime.js
 import { EXECUTE_OUTPUT } from "./meta-output.js";
 import { normalizeProgramSource } from "./program-source.js";
 import { readResource } from "./resource-read.js";
-import { agentOutputOperations, redactAgentOutput, sentSecretsForRequest } from "./sent-secrets.js";
+import { redactAgentOutput, sentSecretsForRequest } from "./sent-secrets.js";
 import { normalizeTimeoutMs } from "./timeout.js";
 import { fromSignal, runEdge, withDeadlineEffect } from "./runtime/run.js";
 import { closeScope } from "./runtime/connector-scope.js";
+import { RequestScope, requestOwner } from "./runtime/request-scope.js";
 import { executorProgram } from "./runtime/executor.js";
 import { connectorGuide, connectorGuideRequired, connectorSkillName, hasConnectorGuides, SkillsRegistry, } from "./skills.js";
 /** Keep one model-written program from amplifying into an unbounded fan-out. */
@@ -174,13 +175,15 @@ export class EmitCollector {
     maxBytes;
     maxBlocks;
     diagnostics;
+    maxResultChars;
     blocks = [];
     bytes = 0;
     textChars = 0;
-    constructor(maxBytes, maxBlocks, diagnostics) {
+    constructor(maxBytes, maxBlocks, diagnostics, maxResultChars = MAX_EXECUTE_RESULT_CHARS) {
         this.maxBytes = maxBytes;
         this.maxBlocks = maxBlocks;
         this.diagnostics = diagnostics;
+        this.maxResultChars = maxResultChars;
     }
     accept(raw) {
         this.acceptNative([requireEmittedBlock(raw)]);
@@ -204,8 +207,8 @@ export class EmitCollector {
             // the transport budget, just like images and audio.
             if (block.type === "resource" && "text" in block.resource)
                 textChars += serialized.length;
-            if (textChars > MAX_EXECUTE_RESULT_CHARS - 512) {
-                throw guestFailure("result_too_large", "Emitted text shares the 24,000-character program result limit. Reduce the text before emitting it.");
+            if (textChars > this.maxResultChars - 512) {
+                throw guestFailure("result_too_large", `Emitted text shares the ${this.maxResultChars.toLocaleString("en-US")}-character program result limit. Reduce the text before emitting it.`);
             }
             count++;
             bytes += size;
@@ -469,8 +472,20 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
         ...(limits.dispatchController ? { dispatchSignal: limits.dispatchController.signal } : {}),
         unwrapResult: true,
         readOnly: limits.readOnly,
-        processResult: async (value, resolved, secrets, format, raw) => {
-            const page = (data, valueFormat, wireBytes) => pageProgramResult(registry, baseUrl, resolved, data, valueFormat, secrets, requestScope, wireBytes);
+        processResult: authMethod((value, resolved, secrets, format, raw) => Effect.gen(function* () {
+            // Dispatch succeeded before presentation began. Cancellation of paging
+            // cannot turn this completed write into an unknown or failed write.
+            sending.settle?.("ok");
+            const page = (data, valueFormat, wireBytes) => authCall(pageProgramResult, [
+                registry,
+                baseUrl,
+                resolved,
+                data,
+                valueFormat,
+                secrets,
+                requestScope,
+                wireBytes,
+            ]);
             const envelope = resolved.connector.kind === "mcp" && raw !== null && typeof raw === "object"
                 ? raw
                 : undefined;
@@ -485,12 +500,12 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
             // the structured value synchronously; no native metadata is visited.
             if (dataKey !== undefined &&
                 diagnosticsEncoder.encode(JSON.stringify(value)).byteLength > PROGRAM_RESULT_INLINE_BYTES) {
-                return page(value, format, PROGRAM_RESULT_WIRE_BYTES - 1024);
+                return yield* page(value, format, PROGRAM_RESULT_WIRE_BYTES - 1024);
             }
             const content = envelope?.content;
             if (!Array.isArray(content) ||
                 !content.some((block) => block && ["image", "audio", "resource", "resource_link"].includes(block.type))) {
-                return transportResult(await page(value, format));
+                return transportResult(yield* page(value, format));
             }
             const unavailablePresentation = () => ({
                 format: "paged",
@@ -516,7 +531,7 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
             catch (error) {
                 if (!(error instanceof NativePresentationLimit))
                     throw error;
-                const result = dataKey === undefined ? undefined : transportResult(await page(value, format));
+                const result = dataKey === undefined ? undefined : transportResult(yield* page(value, format));
                 const notice = unavailablePresentation();
                 return result ? { value: result, native: { value: notice } } : notice;
             }
@@ -525,8 +540,9 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
             // original bytes even if the structured-data stash pauses.
             const resultPending = dataKey === undefined ? undefined : page(value, format, PROGRAM_RESULT_WIRE_BYTES - 1024);
             const nativePending = page(snapshot, "json");
-            const result = await resultPending;
-            const native = await nativePending;
+            const [result, native] = yield* Effect.all([resultPending ?? Effect.succeed(undefined), nativePending], {
+                concurrency: "unbounded",
+            });
             let valueResult;
             if (native.format === "paged") {
                 valueResult = result ? transportResult(result) : undefined;
@@ -548,7 +564,7 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
                 ...(valueResult ? { value: valueResult } : {}),
                 native: { ref, value: transportResult(native), dataKey },
             };
-        },
+        })),
         beforeWrite: (target) => Effect.sync(() => {
             if (programWrites?.isClosed) {
                 return {
@@ -736,8 +752,10 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
         }),
         skill: (name, _options, utilitySignal) => Effect.tryPromise({
             try: async () => {
-                if (typeof name !== "string")
-                    throw guestFailure("invalid_args", "Use connecta.skill(name) with an exact skill name.");
+                // Accept the top-level skills tool's { name } shape too: models copy it into programs.
+                const skillName = name && typeof name === "object" ? name.name : name;
+                if (typeof skillName !== "string")
+                    throw guestFailure("invalid_args", 'Use connecta.skill("usage") or connecta.skill("connector:<id>") with an exact skill name; the skills tool lists names.');
                 const skills = new SkillsRegistry(registry, baseUrl, {
                     requestScope,
                     requestSignal: utilitySignal ?? hostAccessSignal,
@@ -749,7 +767,7 @@ function sandboxProvider(registry, baseUrl, activity, limits, requestScope = {})
                     probeTimeoutMs: limits.probeTimeoutMs,
                     defer: limits.defer,
                 });
-                return { name, format: "text", text: await skills.text(name) };
+                return { name: skillName, format: "text", text: await skills.text(skillName) };
             },
             catch: (err) => err instanceof ConnectorCallError ? guestFailure(err.code, err.message, err.code === "unavailable") : err,
         }),
@@ -1030,12 +1048,11 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
         logger,
     };
     const hostCallTimeoutMs = resolveBudget(config.hostCallTimeoutMs, EXECUTE_HOST_CALL_TIMEOUT_MS);
-    const play = (program, diagnosticsRequested, callerSignal, requestScope) => Effect.suspend(() => {
+    const maxResultChars = resolveBudget(config.maxResultChars, MAX_EXECUTE_RESULT_CHARS);
+    const play = (program, diagnosticsRequested, callerSignal, requestScope, hostCalls, programWrites) => Effect.suspend(() => {
         const sentSecrets = sentSecretsForRequest(requestScope);
         const diagnostics = diagnosticsRequested ? new ExecuteDiagnostics() : undefined;
-        const emitted = new EmitCollector(resolveBudget(config.maxEmittedBytes, EXECUTE_MAX_EMITTED_BYTES), resolveBudget(config.maxEmittedBlocks, EXECUTE_MAX_EMITTED_BLOCKS), diagnostics);
-        const hostCalls = { attempted: 0, admitted: 0, succeeded: 0, failed: 0 };
-        const programWrites = new ProgramWrites();
+        const emitted = new EmitCollector(resolveBudget(config.maxEmittedBytes, EXECUTE_MAX_EMITTED_BYTES), resolveBudget(config.maxEmittedBlocks, EXECUTE_MAX_EMITTED_BLOCKS), diagnostics, maxResultChars);
         const resultDependencies = [];
         const dispatchController = new AbortController();
         const terminal = Deferred.makeUnsafe();
@@ -1116,21 +1133,34 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
             }).pipe(Effect.map((outcome) => sentSecrets.redact(outcome)), Effect.mapError((error) => sentSecrets.redact(error))), signal, { watchdog, terminal: Deferred.await(terminal) }).pipe(Effect.ensuring(Effect.suspend(() => {
                 programWrites.close();
                 dispatchController.abort();
-                return programWrites.drain();
+                // Finalizers are masked by default. The request must be able
+                // to stop this wait as well as the invocations being drained.
+                return programWrites.drain().pipe(Effect.interruptible);
             }))));
         });
         const reported = {
             emitted,
             diagnostics,
             program,
-            guardResult: (value, maxChars) => guardProgramReturn(value, registry, baseUrl, [...new Map(resultDependencies.map((dependency) => [JSON.stringify(dependency), dependency])).values()], sentSecrets, logger, maxChars, programWrites.hasSucceeded),
+            // Emitted text shares the return cap; a follow-up page run gets all of it.
+            guardResult: (value) => authCall(guardProgramReturn, [
+                value,
+                registry,
+                baseUrl,
+                [...new Map(resultDependencies.map((dependency) => [JSON.stringify(dependency), dependency])).values()],
+                sentSecrets,
+                logger,
+                maxResultChars - emitted.textChars,
+                programWrites.hasSucceeded,
+                maxResultChars,
+            ]),
         };
         const exited = Effect.exit(Effect.scoped(run)).pipe(Effect.flatMap((exit) => 
         // Releasing a QuickJS lease ends its child and rejects execute() with
         // the retained log prefix. Give that report one timer turn, just as
         // cancellation does in awaitExecutor; never wait on a Worker isolate.
         budgetFailure ? Effect.sleep(Duration.millis(1)).pipe(Effect.as(exit)) : Effect.succeed(exit)));
-        return Effect.map(Effect.flatMap(exited, (exit) => {
+        return Effect.flatMap(exited, (exit) => {
             // A synchronous fire-and-forget burst can also settle its executor in
             // this turn. The host's terminal refusal always wins over that value.
             if (budgetFailure instanceof HostCallBudgetExceeded) {
@@ -1145,36 +1175,47 @@ export function createExecuteTool(registry, baseUrl, executor, logger, activity,
             if (Exit.isFailure(exit)) {
                 return Effect.succeed(failedRun(redactAgentOutput(sentSecrets, Cause.squash(exit.cause)), logger, reported));
             }
-            return Effect.promise(() => finishedRun(redactAgentOutput(sentSecrets, exit.value), reported));
-        }), (unfinished) => {
-            // Every run response passes through write accounting.
-            const response = programWrites.finish(unfinished);
-            // Calls abandoned by the guest are failed when the run cancels them.
-            const counts = { ...hostCalls, failed: hostCalls.attempted - hostCalls.succeeded };
-            response.structuredContent = { ...response.structuredContent, hostCalls: counts };
-            if (response.content[0]?.type === "text")
-                response.content[0].text = JSON.stringify(response.structuredContent);
-            return response;
-        }).pipe(Effect.map((result) => redactAgentOutput(sentSecrets, result)));
+            // The executor lease is already released, but presenting its return
+            // still belongs to the caller. Compose the registered stash program
+            // here so cancellation interrupts storage waits and their continuations.
+            const cancelled = new ExecutorAdmissionError("executor_cancelled", "Execution was cancelled during result processing.");
+            return withDeadlineEffect(() => finishedRun(redactAgentOutput(sentSecrets, exit.value), reported), {
+                ...(callerSignal ? { signal: callerSignal } : {}),
+                timeoutError: cancelled,
+            }).pipe(Effect.catch((error) => Effect.succeed(failedRun(callerSignal?.aborted ? cancelled : error, logger, reported))));
+        });
     });
-    return agentOutputOperations((requestScope) => ({
-        execute: authMethod(({ code, diagnostics }, options = {}) => {
+    return authMethod(({ code, diagnostics }, options = {}) => Effect.suspend(() => {
+        const requestScope = config.requestScope ?? {};
+        const sentSecrets = sentSecretsForRequest(requestScope);
+        const owner = requestOwner(requestScope);
+        if (!owner.open)
+            return Effect.fail(owner.controller.signal.reason);
+        const hostCalls = { attempted: 0, admitted: 0, succeeded: 0, failed: 0 };
+        const programWrites = new ProgramWrites();
+        const response = Effect.suspend(() => {
             // A code-unit count above the cap is already too large in UTF-8. Check
             // that first so a huge direct-call string is never encoded in full.
             if (code.length > EXECUTE_MAX_CODE_BYTES ||
                 new TextEncoder().encode(code).byteLength > EXECUTE_MAX_CODE_BYTES) {
                 const message = `execute_code code exceeds the ${EXECUTE_MAX_CODE_BYTES}-byte UTF-8 limit.`;
-                const response = failureResponse(message, { code: { code: "invalid_args", message, retryable: false } });
-                response.structuredContent = {
-                    ...response.structuredContent,
-                    hostCalls: { attempted: 0, admitted: 0, succeeded: 0, failed: 0 },
-                };
-                response.content[0].text = JSON.stringify(response.structuredContent);
-                return Effect.succeed(response);
+                return Effect.succeed(failureResponse(message, { code: { code: "invalid_args", message, retryable: false } }));
             }
-            return Effect.suspend(() => play(normalizeProgramSource(code), diagnostics, options.signal, requestScope));
-        }),
-    }), config.requestScope).execute;
+            return play(normalizeProgramSource(code), diagnostics, options.signal, requestScope, hostCalls, programWrites);
+        });
+        return response.pipe(Effect.provideService(RequestScope, owner), Effect.map((unfinished) => {
+            // Every response, including intake refusals, crosses accounting and
+            // exactly one envelope check at this operation boundary.
+            const result = redactAgentOutput(sentSecrets, programWrites.finish(unfinished));
+            // Calls abandoned by the guest are failed when the run cancels them.
+            // Connecta attaches its own integers after the envelope check.
+            const counts = { ...hostCalls, failed: hostCalls.attempted - hostCalls.succeeded };
+            result.structuredContent = { ...result.structuredContent, hostCalls: counts };
+            if (result.content[0]?.type === "text")
+                result.content[0].text = JSON.stringify(result.structuredContent);
+            return result;
+        }), Effect.catchDefect(Effect.fail), Effect.mapError((error) => redactAgentOutput(sentSecrets, error)));
+    }));
 }
 /** An execution that never produced an ExecuteResult, as the model sees it. */
 function failedRun(err, logger, { emitted, diagnostics, program }) {
@@ -1215,81 +1256,83 @@ function failedRun(err, logger, { emitted, diagnostics, program }) {
     });
 }
 /** The response for an ExecuteResult: the program's error or its value. */
-async function finishedRun(outcome, { emitted, diagnostics, program, guardResult }) {
-    if (outcome === null || typeof outcome !== "object" || Array.isArray(outcome)) {
-        return failureResponse("Executor failed: expected an ExecuteResult object.", {
-            emitted,
-            diagnostics,
-            code: "executor_failed",
-        });
-    }
-    const logs = executeLogs(outcome.logs);
-    if (outcome.error !== undefined && typeof outcome.error !== "string") {
-        return failureResponse("Executor failed: ExecuteResult.error must be a string.", {
-            logs,
-            emitted,
-            diagnostics,
-            code: "executor_failed",
-        });
-    }
-    if (outcome.error !== undefined) {
-        const failure = outcome.failure?.call;
-        if (outcome.failure?.timeout) {
-            const { elapsedMs, deadlineMs } = outcome.failure.timeout;
-            const message = `Operation "execute_code" timed out during sandbox after ${elapsedMs}ms (effective deadline ${deadlineMs}ms).`;
+function finishedRun(outcome, { emitted, diagnostics, program, guardResult }) {
+    return authFlow(function* () {
+        if (outcome === null || typeof outcome !== "object" || Array.isArray(outcome)) {
+            return failureResponse("Executor failed: expected an ExecuteResult object.", {
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
+        }
+        const logs = executeLogs(outcome.logs);
+        if (outcome.error !== undefined && typeof outcome.error !== "string") {
+            return failureResponse("Executor failed: ExecuteResult.error must be a string.", {
+                logs,
+                emitted,
+                diagnostics,
+                code: "executor_failed",
+            });
+        }
+        if (outcome.error !== undefined) {
+            const failure = outcome.failure?.call;
+            if (outcome.failure?.timeout) {
+                const { elapsedMs, deadlineMs } = outcome.failure.timeout;
+                const message = `Operation "execute_code" timed out during sandbox after ${elapsedMs}ms (effective deadline ${deadlineMs}ms).`;
+                return failureResponse(message, {
+                    logs,
+                    emitted,
+                    diagnostics,
+                    code: {
+                        code: "timeout",
+                        message,
+                        retryable: false,
+                        details: { operation: "execute_code", stage: "sandbox", elapsedMs, deadlineMs },
+                    },
+                });
+            }
+            return failureResponse(failure?.message ?? outcome.error, {
+                logs,
+                emitted,
+                diagnostics,
+                code: failure ??
+                    programError({
+                        name: outcome.failure?.name ?? /^(SyntaxError|ReferenceError|TypeError|RangeError):/.exec(outcome.error)?.[1],
+                        message: outcome.error || "Execution failed without an error message.",
+                        ...(outcome.failure?.line !== undefined ? { line: outcome.failure.line - 1 } : {}),
+                    }, program),
+            });
+        }
+        // A result crossing back as a host BigInt (or otherwise unserializable
+        // value) makes JSON.stringify throw — keep that inside the structured
+        // error path so captured logs survive instead of a raw SDK 500.
+        let result;
+        try {
+            result = yield* guardResult(outcome.result);
+        }
+        catch (err) {
+            const message = `Error: result is not JSON-serializable: ${msg(err)}`;
             return failureResponse(message, {
                 logs,
                 emitted,
                 diagnostics,
-                code: {
-                    code: "timeout",
-                    message,
-                    retryable: false,
-                    details: { operation: "execute_code", stage: "sandbox", elapsedMs, deadlineMs },
-                },
+                code: "executor_failed",
             });
         }
-        return failureResponse(failure?.message ?? outcome.error, {
-            logs,
-            emitted,
-            diagnostics,
-            code: failure ??
-                programError({
-                    name: outcome.failure?.name ?? /^(SyntaxError|ReferenceError|TypeError|RangeError):/.exec(outcome.error)?.[1],
-                    message: outcome.error || "Execution failed without an error message.",
-                    ...(outcome.failure?.line !== undefined ? { line: outcome.failure.line - 1 } : {}),
-                }, program),
-        });
-    }
-    // A result crossing back as a host BigInt (or otherwise unserializable
-    // value) makes JSON.stringify throw — keep that inside the structured
-    // error path so captured logs survive instead of a raw SDK 500.
-    let result;
-    try {
-        result = await guardResult(outcome.result, MAX_EXECUTE_RESULT_CHARS - emitted.textChars);
-    }
-    catch (err) {
-        const message = `Error: result is not JSON-serializable: ${msg(err)}`;
-        return failureResponse(message, {
-            logs,
-            emitted,
-            diagnostics,
-            code: "executor_failed",
+        const response = jsonResult({
+            result,
+            ...(emitted.blocks.length > 0 ? { emitted: emitted.blocks.length } : {}),
+            ...(logs ? { logs } : {}),
+            ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
         });
-    }
-    const response = jsonResult({
-        result,
-        ...(emitted.blocks.length > 0 ? { emitted: emitted.blocks.length } : {}),
-        ...(logs ? { logs } : {}),
-        ...(diagnostics ? { diagnostics: diagnostics.finish() } : {}),
+        if (emitted.blocks.length > 0) {
+            // Emitted image/audio blocks are valid MCP content that ToolResult's
+            // text-only typing does not model — the same acknowledged gap
+            // guardContent lives with for downstream block passthrough.
+            response.content.push(...emitted.blocks);
+        }
+        return response;
     });
-    if (emitted.blocks.length > 0) {
-        // Emitted image/audio blocks are valid MCP content that ToolResult's
-        // text-only typing does not model — the same acknowledged gap
-        // guardContent lives with for downstream block passthrough.
-        response.content.push(...emitted.blocks);
-    }
-    return response;
 }
 function executeLogs(value) {
     return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string")
@@ -1345,7 +1388,7 @@ function connectorInventory(connectors) {
         return `${prefix}${shown.join(", ")}.`;
     return `${prefix}${shown.join(", ")}${shown.length > 0 ? "; " : ""}+${omitted} more.`;
 }
-const executeDescription = (emitBudgets, hostLimits, connectorGuides, connectors, maxWrites, readOnly, native = false) => `${native ? `Call tools directly; combine work here using their program addresses. ${readOnly ? "Read-only endpoint: writes are omitted and refused." : "Writable endpoint: programs may read and write; the client approves."}` : readOnly ? "One known read: call_tool. Everything else: execute_code. Read-only endpoint: search and describe omit write tools, and every write call is refused." : "One known read: call_tool. One known write: call_destructive_tool. Everything else: execute_code. Writable endpoint: programs may read and write; the client approves."} Limits: ${hostLimits.maxHostCalls} host calls, ${readOnly ? "" : `${maxWrites} writes, `}${hostLimits.hostCallTimeoutMs / 1_000}s/host call.
+const executeDescription = (emitBudgets, hostLimits, connectorGuides, connectors, maxWrites, readOnly, native = false) => `${native ? `Call tools directly; combine work here using their program addresses. ${readOnly ? "Read-only endpoint: writes are omitted and refused." : "Writable endpoint: programs may read and write; the client approves."}` : readOnly ? "One known read: call_tool. Everything else: execute_code. Read-only endpoint: search and describe omit write tools, and every write call is refused." : "One known read: call_tool. One known write: call_destructive_tool. Everything else: execute_code. Writable endpoint: programs may read and write; the client approves."} Limits: ${hostLimits.maxHostCalls} host calls, ${readOnly ? "" : `${maxWrites} writes, `}${hostLimits.callTimeoutMs === hostLimits.hostCallTimeoutMs ? `${hostLimits.callTimeoutMs / 1_000}s/host call` : `${hostLimits.callTimeoutMs / 1_000}s/call (${hostLimits.hostCallTimeoutMs / 1_000}s result/skill/read)`}.
 ${connectorInventory(connectors)}
 
 Use async () => { ... }, no arguments. No portable ambient capabilities. API:
@@ -1356,7 +1399,7 @@ ${GUEST_API_DECLARATION}
 \`\`\`
 Search: {tools}, catalogErrors. JSON schemas default; compact text. Calls: {data, format:"json"|"text"}; >1 MiB: paged handle. Oversized returns: resultId/nextAction. connecta.result pages; UTF-8 byte offsets. allSettled keeps typed errors; host budget_exceeded ends the run.
 
-Never repeat writes for output. emit(result) or emit(block) from result.content forwards MCP blocks. Authored: text/base64 image/audio; no await. Caps: ${emitBudgets.maxBlocks} blocks/${emitBudgets.maxBytes} bytes. Text shares result cap. skills({ name: "investigate" }): workflow; skills({ name: "usage" }): repair${connectorGuides ? ", guide handling" : ""}.`;
+Never repeat writes for output. emit(result) or emit(block) from result.content forwards MCP blocks. Authored: text/base64 image/audio; no await. Caps: ${emitBudgets.maxBlocks} blocks/${emitBudgets.maxBytes} bytes. Text shares result cap. connecta.skill("usage"): repair${connectorGuides ? ", guide handling" : ""}; connecta.skill("investigate"): workflow.`;
 // Module scope, like the other five meta-tool inputs: its JSON Schema is
 // derived once per process. Budgets and connectors vary by deployment and
 // view, so they live in the description, never here.
@@ -1394,12 +1437,14 @@ export function registerExecuteTool(server, registry, ctx) {
         defer: ctx.defer,
         readOnly: ctx.readOnly,
         maxWrites,
+        maxResultChars: ctx.maxResultChars,
         requestScope: ctx.requestScope,
     });
     server.registerTool("execute_code", {
         description: executeDescription(emitBudgets, {
             ...hostLimits,
-            hostCallTimeoutMs: normalizeTimeoutMs(ctx.defaultToolTimeoutMs) ?? hostLimits.hostCallTimeoutMs,
+            // connecta.call falls back to calls.defaultTimeoutMs; result, skill and read always use hostCallTimeoutMs.
+            callTimeoutMs: normalizeTimeoutMs(ctx.defaultToolTimeoutMs) ?? hostLimits.hostCallTimeoutMs,
         }, hasConnectorGuides(connectors), connectors, maxWrites, ctx.readOnly === true, ctx.native === true),
         inputSchema: EXECUTE_INPUT,
         outputSchema: EXECUTE_OUTPUT,

package/dist/executor-result.js

@@ -1,6 +1,7 @@
+import { CONFIG_DEFAULTS } from "./config-defaults.js";
 import { msg } from "./errors.js";
 /** ~6k tokens. Sandbox code should filter data down before returning. */
-export const MAX_EXECUTE_RESULT_CHARS = 24_000;
+export const MAX_EXECUTE_RESULT_CHARS = CONFIG_DEFAULTS.execute.maxResultChars;
 export const MAX_EXECUTE_LOG_CHARS = 4_000;
 export function serializeResultText(value) {
     const serialized = JSON.stringify(value);