@opencode-ai/codemode 0.0.0-dev-18535 → 0.0.0-dev-18544

package/README.md

@@ -139,8 +139,8 @@ Diagnostic kinds:
 | `ExecutionFailure`      | The program threw or another execution error occurred.                                         |
 | `Truncated`             | Warning only: additional warnings were omitted by `maxOutputBytes`.                            |
 
-Unknown host failures, defects, and invalid outputs are sanitized. `toolError("safe message")` explicitly exposes a
-safe refusal to the model; its optional cause remains private.
+Host failures and defects report their messages and underlying causes. Invalid outputs include the validation or
+copying error. Interruption propagates without becoming an error diagnostic.
 
 ## Discovery
 

package/dist/tool-error.d.ts

@@ -3,9 +3,9 @@ declare const ToolError_base: Schema.Class<ToolError, Schema.TaggedStruct<"ToolE
     readonly message: Schema.String;
     readonly cause: Schema.optionalKey<Schema.Defect>;
 }>, import("effect/Cause").YieldableError>;
-/** Safe operational refusal from a standard tool pack, reported as `ToolFailure`. */
+/** Tool failure reported as `ToolFailure`. */
 export declare class ToolError extends ToolError_base {
 }
-/** Creates a tool refusal whose message is safe to include in an execution diagnostic. */
+/** Creates a tool failure with an optional underlying cause. */
 export declare const toolError: (message: string, cause?: unknown) => ToolError;
 export {};

package/dist/tool-error.js

@@ -1,9 +1,9 @@
 import { Schema } from "effect";
-/** Safe operational refusal from a standard tool pack, reported as `ToolFailure`. */
+/** Tool failure reported as `ToolFailure`. */
 export class ToolError extends Schema.TaggedError()("ToolError", {
     message: Schema.String,
     cause: Schema.optionalKey(Schema.Defect()),
 }) {
 }
-/** Creates a tool refusal whose message is safe to include in an execution diagnostic. */
+/** Creates a tool failure with an optional underlying cause. */
 export const toolError = (message, cause) => new ToolError({ message, ...(cause === undefined ? {} : { cause }) });

package/dist/tool-runtime.js

@@ -1,5 +1,5 @@
-import { Cause, Effect, Exit, Schema } from "effect";
-import { ToolError, toolError } from "./tool-error.js";
+import { Cause, Effect, Exit, Formatter, Schema } from "effect";
+import { toolError } from "./tool-error.js";
 import { decodeInput as decodeToolInput, decodeOutput as decodeToolOutput, identifierSegment, inputProperties, inputTypeScript, outputTypeScript, } from "./tool-schema.js";
 import { isTool } from "./tool.js";
 import { CodeModeDate, CodeModeMap, CodeModePromise, CodeModeRegExp, CodeModeSet, CodeModeURL, CodeModeURLSearchParams, } from "./values.js";
@@ -45,12 +45,6 @@ export class ToolRuntimeError extends Error {
         this.name = "ToolRuntimeError";
     }
 }
-const runHost = (effect) => effect.pipe(Effect.catchCause((cause) => {
-    if (Cause.hasInterruptsOnly(cause))
-        return Effect.interrupt;
-    const error = Cause.squash(cause);
-    return Effect.fail(error instanceof ToolError ? error : toolError("Tool execution failed", error));
-}));
 const blockedMemberNames = new Set(["__proto__", "constructor", "prototype"]);
 export const isBlockedMember = (name) => blockedMemberNames.has(name);
 // Checkpoint mode preserves CodeMode values; boundary mode JSON-normalizes them.
@@ -337,14 +331,10 @@ export const make = (tools, maxToolCalls, searchIndex, hooks) => {
             if (Cause.hasInterruptsOnly(exit.cause))
                 return onEnd({ ...call, durationMs, outcome: "interrupted" });
             const error = Cause.squash(exit.cause);
-            const message = error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed";
+            const message = error instanceof Error ? error.message : Cause.pretty(exit.cause);
             return onEnd({ ...call, durationMs, outcome: "failure", message });
         }));
     };
-    const decodeOutput = (value, name) => Effect.try({
-        try: () => copyIn(value, `Result from tool '${name}'`),
-        catch: () => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}'.`),
-    });
     const recordCall = (call) => {
         if (maxToolCalls !== undefined && calls.length >= maxToolCalls) {
             throw new ToolRuntimeError("ToolCallLimitExceeded", `Execution exceeded its tool-call limit of ${maxToolCalls}.`);
@@ -366,12 +356,17 @@ export const make = (tools, maxToolCalls, searchIndex, hooks) => {
         return yield* observeEnd(Effect.gen(function* () {
             if (hooks?.onToolCallStart !== undefined)
                 yield* hooks.onToolCallStart(call);
-            const raw = yield* runHost(Effect.suspend(() => tool.execute(input)));
-            const result = yield* Effect.try({
-                try: () => decodeToolOutput(tool, raw),
-                catch: () => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}'.`),
+            const raw = yield* Effect.suspend(() => tool.execute(input)).pipe(Effect.catchCause((cause) => {
+                if (Cause.hasInterruptsOnly(cause))
+                    return Effect.interrupt;
+                return Effect.fail(toolError(Cause.prettyErrors(cause)
+                    .map((error) => (error.cause ? Formatter.format(error) : error.message || error.name))
+                    .join("\n")));
+            }));
+            return yield* Effect.try({
+                try: () => copyIn(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+                catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
             });
-            return yield* decodeOutput(result, name);
         }), call);
     });
     return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/codemode",
-  "version": "0.0.0-dev-18535",
+  "version": "0.0.0-dev-18544",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",