@rcrsr/rill-ext-gemini 0.18.4 → 0.19.0

package/dist/index.js

@@ -7,11 +7,13 @@ import {
   Type
 } from "@google/genai";
 import {
-  RuntimeError as RuntimeError6,
+  RuntimeError as RuntimeError5,
+  RuntimeHaltSignal as RuntimeHaltSignal3,
   emitExtensionEvent,
   createRillStream,
   createVector,
   isVector,
+  getStatus as getStatus2,
   structureToTypeValue,
   toCallable
 } from "@rcrsr/rill";
@@ -67,27 +69,133 @@ function validateEmbedModel(model) {
 }
 
 // ../../shared/ext-llm/dist/errors.js
-import { RuntimeError as RuntimeError2 } from "@rcrsr/rill";
-function mapProviderError(providerName, error, detect) {
+import { RuntimeHaltSignal } from "@rcrsr/rill";
+function atomForStatus(status) {
+  if (status === 401)
+    return "AUTH";
+  if (status === 403)
+    return "FORBIDDEN";
+  if (status === 404)
+    return "NOT_FOUND";
+  if (status === 408)
+    return "TIMEOUT";
+  if (status === 409 || status === 412)
+    return "CONFLICT";
+  if (status === 429)
+    return "RATE_LIMIT";
+  if (status === 402)
+    return "QUOTA_EXCEEDED";
+  if (status >= 500 && status <= 599)
+    return "UNAVAILABLE";
+  if (status >= 400 && status <= 499)
+    return "INVALID_INPUT";
+  return "UNAVAILABLE";
+}
+function kindForStatus(status) {
+  if (status === 401)
+    return "authentication_failed";
+  if (status === 403)
+    return "forbidden";
+  if (status === 404)
+    return "not_found";
+  if (status === 408)
+    return "request_timeout";
+  if (status === 409 || status === 412)
+    return "conflict";
+  if (status === 429)
+    return "rate_limit_exceeded";
+  if (status === 402)
+    return "quota_exceeded";
+  if (status >= 500 && status <= 599)
+    return "server_error";
+  return "http_error";
+}
+function mapProviderError(ctx, provider, error, detect) {
+  if (error instanceof RuntimeHaltSignal) {
+    return ctx.invalidate(error, {
+      code: "TIMEOUT",
+      provider,
+      raw: { kind: "request_cancelled", message: `${provider}: request cancelled` }
+    });
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return ctx.invalidate(error, {
+      code: "TIMEOUT",
+      provider,
+      raw: {
+        kind: "request_timeout",
+        message: `${provider} error: ${error.message}`
+      }
+    });
+  }
   const detected = detect(error);
   if (detected !== null) {
     const { status, message } = detected;
     if (status !== void 0) {
-      return new RuntimeError2("RILL-R004", `${providerName} API error (HTTP ${status}): ${message}`, void 0, { cause: error });
+      return ctx.invalidate(error, {
+        code: atomForStatus(status),
+        provider,
+        raw: {
+          kind: kindForStatus(status),
+          status,
+          message: `${provider} API error (HTTP ${status}): ${message}`
+        }
+      });
     }
-    return new RuntimeError2("RILL-R004", `${providerName} API error: ${message}`, void 0, { cause: error });
+    return ctx.invalidate(error, {
+      code: "UNAVAILABLE",
+      provider,
+      raw: {
+        kind: "provider_error",
+        message: `${provider} API error: ${message}`
+      }
+    });
+  }
+  if (error instanceof TypeError) {
+    return ctx.invalidate(error, {
+      code: "UNAVAILABLE",
+      provider,
+      raw: {
+        kind: "connection_failed",
+        message: `${provider} error: ${error.message}`
+      }
+    });
+  }
+  if (error instanceof SyntaxError) {
+    return ctx.invalidate(error, {
+      code: "PROTOCOL",
+      provider,
+      raw: {
+        kind: "unexpected_response_format",
+        message: `${provider} error: ${error.message}`
+      }
+    });
   }
   if (error instanceof Error) {
-    return new RuntimeError2("RILL-R004", `${providerName} error: ${error.message}`, void 0, { cause: error });
+    return ctx.invalidate(error, {
+      code: "UNAVAILABLE",
+      provider,
+      raw: {
+        kind: "unknown_error",
+        message: `${provider} error: ${error.message}`
+      }
+    });
   }
-  return new RuntimeError2("RILL-R004", `${providerName} error: Unknown error`, void 0, { cause: error });
+  return ctx.invalidate(error, {
+    code: "UNAVAILABLE",
+    provider,
+    raw: {
+      kind: "unknown_error",
+      message: `${provider} error: Unknown error`
+    }
+  });
 }
 
 // ../../shared/ext-llm/dist/tool-loop.js
-import { invokeCallable, isCallable, isDict, isRuntimeCallable, RuntimeError as RuntimeError4 } from "@rcrsr/rill";
+import { getStatus, invokeCallable, isCallable, isDict, isRuntimeCallable, RuntimeError as RuntimeError3, RuntimeHaltSignal as RuntimeHaltSignal2 } from "@rcrsr/rill";
 
 // ../../shared/ext-llm/dist/schema.js
-import { RuntimeError as RuntimeError3 } from "@rcrsr/rill";
+import { RuntimeError as RuntimeError2 } from "@rcrsr/rill";
 var RILL_TYPE_MAP = {
   string: "string",
   number: "number",
@@ -100,13 +208,13 @@ var RILL_TYPE_MAP = {
 function mapRillType(rillType) {
   const jsonType = RILL_TYPE_MAP[rillType];
   if (jsonType === void 0) {
-    throw new RuntimeError3("RILL-R004", `unsupported type: ${rillType}`);
+    throw new RuntimeError2("RILL-R005", `unsupported type: ${rillType}`);
   }
   return jsonType;
 }
 function buildPropertyFromStructuralType(rillType) {
   if (rillType.kind === "closure" || rillType.kind === "tuple") {
-    throw new RuntimeError3("RILL-R004", `unsupported type for JSON Schema: ${rillType.kind}`);
+    throw new RuntimeError2("RILL-R005", `unsupported type for JSON Schema: ${rillType.kind}`);
   }
   if (rillType.kind === "any") {
     return {};
@@ -156,7 +264,7 @@ function buildJsonSchemaFromStructuralType(type, params) {
     return buildDictSchema(type);
   }
   if (type.kind !== "closure") {
-    throw new RuntimeError3("RILL-R004", `unsupported schema kind: ${type.kind} (expected dict or closure)`);
+    throw new RuntimeError2("RILL-R005", `unsupported schema kind: ${type.kind} (expected dict or closure)`);
   }
   const properties = {};
   const required = [];
@@ -184,30 +292,51 @@ function buildJsonSchemaFromStructuralType(type, params) {
 }
 
 // ../../shared/ext-llm/dist/tool-loop.js
+function readHaltMessage(halt) {
+  const status = getStatus(halt.value);
+  if (typeof status.message === "string" && status.message.length > 0) {
+    return status.message;
+  }
+  return halt.message;
+}
+function throwToolLoopHalt(ctx, code, kind, message) {
+  if (ctx !== void 0) {
+    const hostCtx = ctx;
+    if (typeof hostCtx.invalidate === "function") {
+      const invalid = hostCtx.invalidate(new Error(message), {
+        code,
+        provider: "tool_loop",
+        raw: { kind, message }
+      });
+      throw new RuntimeHaltSignal2(invalid, true);
+    }
+  }
+  throw new RuntimeError3("RILL-R005", message);
+}
 async function executeToolCall(toolName, toolInput, tools, context) {
   if (!isDict(tools)) {
-    throw new RuntimeError4("RILL-R004", "tool_loop: tools must be a dict of name \u2192 callable");
+    throwToolLoopHalt(context, "INVALID_INPUT", "tools_not_dict", "tool_loop: tools must be a dict of name \u2192 callable");
   }
   const toolsDict = tools;
   const toolFn = toolsDict[toolName];
   if (toolFn === void 0 || toolFn === null) {
-    throw new RuntimeError4("RILL-R004", `Unknown tool: ${toolName}`);
+    throwToolLoopHalt(context, "NOT_FOUND", "unknown_tool", `Unknown tool: ${toolName}`);
   }
   if (!isCallable(toolFn)) {
-    throw new RuntimeError4("RILL-R004", `Invalid tool input for ${toolName}: tool must be callable`);
+    throwToolLoopHalt(context, "INVALID_INPUT", "tool_not_callable", `Invalid tool input for ${toolName}: tool must be callable`);
   }
   if (typeof toolInput !== "object" || toolInput === null) {
-    throw new RuntimeError4("RILL-R004", `Invalid tool input for ${toolName}: input must be an object`);
+    throwToolLoopHalt(context, "INVALID_INPUT", "invalid_tool_input", `Invalid tool input for ${toolName}: input must be an object`);
   }
   const callable = toolFn;
   if (callable.kind !== "runtime" && callable.kind !== "application" && callable.kind !== "script") {
-    throw new RuntimeError4("RILL-R004", `Invalid tool input for ${toolName}: tool must be application, runtime, or script callable`);
+    throwToolLoopHalt(context, "INVALID_INPUT", "tool_kind_unsupported", `Invalid tool input for ${toolName}: tool must be application, runtime, or script callable`);
   }
   try {
     const inputDict = toolInput;
     if (callable.kind === "script") {
       if (!context) {
-        throw new RuntimeError4("RILL-R004", `Invalid tool input for ${toolName}: script callable requires a runtime context`);
+        throw new RuntimeError3("RILL-R005", `Invalid tool input for ${toolName}: script callable requires a runtime context`);
       }
       let args;
       if (callable.params && callable.params.length > 0) {
@@ -223,16 +352,17 @@ async function executeToolCall(toolName, toolInput, tools, context) {
     const ctx = context ?? {
       parent: void 0,
       variables: /* @__PURE__ */ new Map(),
-      pipeValue: null
+      pipeValue: null,
+      hostContext: {}
     };
     const result = callable.fn(inputDict, ctx);
     return result instanceof Promise ? await result : result;
   } catch (error) {
-    if (error instanceof RuntimeError4) {
+    if (error instanceof RuntimeError3) {
       throw error;
     }
     const message = error instanceof Error ? error.message : "Unknown error";
-    throw new RuntimeError4("RILL-R004", `Invalid tool input for ${toolName}: ${message}`);
+    throw new RuntimeError3("RILL-R005", `Invalid tool input for ${toolName}: ${message}`);
   }
 }
 function sanitizeToolName(name) {
@@ -303,19 +433,19 @@ function patchResponseToolCallNames(response, nameMap) {
 }
 async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent, maxTurns = 10, context, yieldChunk, signal) {
   if (tools === void 0) {
-    throw new RuntimeError4("RILL-R004", "tools parameter is required");
+    throwToolLoopHalt(context, "INVALID_INPUT", "tools_required", "tools parameter is required");
   }
   if (!isDict(tools)) {
-    throw new RuntimeError4("RILL-R004", "tool_loop: tools must be a dict of name \u2192 callable");
+    throwToolLoopHalt(context, "INVALID_INPUT", "tools_not_dict", "tool_loop: tools must be a dict of name \u2192 callable");
   }
   const toolsDict = tools;
   const toolDescriptors = Object.entries(toolsDict).map(([name, fn]) => {
     const fnValue = fn;
     if (isRuntimeCallable(fnValue)) {
-      throw new RuntimeError4("RILL-R004", `tool_loop: builtin "${name}" cannot be used as a tool \u2014 wrap in a closure`);
+      throwToolLoopHalt(context, "INVALID_INPUT", "builtin_tool_unsupported", `tool_loop: builtin "${name}" cannot be used as a tool \u2014 wrap in a closure`);
     }
     if (!isCallable(fnValue)) {
-      throw new RuntimeError4("RILL-R004", `tool_loop: tool "${name}" is not a callable`);
+      throwToolLoopHalt(context, "INVALID_INPUT", "tool_not_callable", `tool_loop: tool "${name}" is not a callable`);
     }
     const callable = fnValue;
     const description = callable.annotations?.["description"] ?? "";
@@ -350,7 +480,7 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
   let turnCount = 0;
   while (turnCount < maxTurns) {
     if (signal?.aborted) {
-      throw new RuntimeError4("RILL-R004", "tool_loop cancelled");
+      throwToolLoopHalt(context, "TIMEOUT", "tool_loop_cancelled", "tool_loop cancelled");
     }
     turnCount++;
     let response;
@@ -364,8 +494,18 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
         response = await callbacks.callAPI(currentMessages, providerTools, signal);
       }
     } catch (error) {
+      if (error instanceof RuntimeHaltSignal2) {
+        throw error;
+      }
+      if (context !== void 0 && callbacks.detectError !== void 0) {
+        const hostCtx = context;
+        if (typeof hostCtx.invalidate === "function") {
+          const invalid = mapProviderError(hostCtx, "tool_loop", error, callbacks.detectError);
+          throw new RuntimeHaltSignal2(invalid, true);
+        }
+      }
       const message = error instanceof Error ? error.message : "Unknown error";
-      throw new RuntimeError4("RILL-R004", `Provider API error: ${message}`, void 0, { cause: error });
+      throw new RuntimeError3("RILL-R005", `Provider API error: ${message}`, void 0, { cause: error });
     }
     if (typeof response === "object" && response !== null && "usage" in response) {
       const usage = response["usage"];
@@ -422,7 +562,11 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
         const duration = Date.now() - toolStartTime;
         consecutiveErrors++;
         let originalError;
-        if (error instanceof RuntimeError4) {
+        if (error instanceof RuntimeHaltSignal2) {
+          const haltMessage = readHaltMessage(error);
+          const prefix = `Invalid tool input for ${name}: `;
+          originalError = haltMessage.startsWith(prefix) ? haltMessage.slice(prefix.length) : haltMessage;
+        } else if (error instanceof RuntimeError3) {
           const prefix = `Invalid tool input for ${name}: `;
           if (error.message.startsWith(prefix)) {
             originalError = error.message.slice(prefix.length);
@@ -447,7 +591,7 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
           duration
         });
         if (consecutiveErrors >= maxErrors) {
-          throw new RuntimeError4("RILL-R004", `Tool execution failed: ${maxErrors} consecutive errors (last: ${name}: ${originalError})`);
+          throwToolLoopHalt(context, "UNAVAILABLE", "consecutive_tool_errors", `Tool execution failed: ${maxErrors} consecutive errors (last: ${name}: ${originalError})`);
         }
       }
     }
@@ -474,13 +618,13 @@ function buildResponseMessages(inputMessages, assistantContent) {
 }
 
 // ../../shared/ext-param/dist/param.js
-import { RuntimeError as RuntimeError5 } from "@rcrsr/rill";
+import { RuntimeError as RuntimeError4 } from "@rcrsr/rill";
 function validateParamName(name) {
   if (name === "") {
-    throw new RuntimeError5("RILL-R001", "param name must not be empty");
+    throw new RuntimeError4("RILL-R001", "param name must not be empty");
   }
   if (/\s/.test(name)) {
-    throw new RuntimeError5("RILL-R001", "param name must be a valid identifier");
+    throw new RuntimeError4("RILL-R001", "param name must be a valid identifier");
   }
 }
 function buildAnnotations(desc) {
@@ -597,6 +741,27 @@ var p = {
 
 // src/factory.ts
 var DEFAULT_MAX_TOKENS = 8192;
+function mapToHalt(ctx, error) {
+  const invalid = mapProviderError(ctx, "Gemini", error, detectGeminiError);
+  return new RuntimeHaltSignal3(invalid, true);
+}
+function haltInvalid(ctx, code, rawKind, message) {
+  return new RuntimeHaltSignal3(
+    ctx.invalidate(new Error(message), {
+      code,
+      provider: "gemini",
+      raw: { kind: rawKind, message }
+    }),
+    true
+  );
+}
+function streamErrorMessage(err) {
+  if (err === void 0) return "";
+  if (err instanceof RuntimeHaltSignal3) {
+    return getStatus2(err.value).message || err.message;
+  }
+  return err.message;
+}
 var detectGeminiError = (error) => {
   if (error instanceof Error) {
     const message = error.message;
@@ -685,7 +850,7 @@ function createGeminiExtension(config) {
         const text = args["text"];
         const options = args["options"] ?? {};
         if (text.trim().length === 0) {
-          throw new RuntimeError6("RILL-R004", "prompt text cannot be empty");
+          throw haltInvalid(ctx, "INVALID_INPUT", "empty_prompt", "prompt text cannot be empty");
         }
         const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
         const maxTokens = typeof options["max_tokens"] === "number" && options["max_tokens"] > 0 ? options["max_tokens"] : factoryMaxTokens;
@@ -724,12 +889,12 @@ function createGeminiExtension(config) {
               }
             }
           } catch (error) {
-            streamError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+            streamError = error instanceof RuntimeError5 || error instanceof RuntimeHaltSignal3 ? error : mapToHalt(ctx, error);
             const duration = Date.now() - messageStartTime;
             emitExtensionEvent(ctx, {
               event: "gemini:error",
               subsystem: "extension:gemini",
-              error: streamError.message,
+              error: streamErrorMessage(streamError),
               duration
             });
             throw streamError;
@@ -820,10 +985,7 @@ function createGeminiExtension(config) {
         const inputMessages = args["messages"];
         const options = args["options"] ?? {};
         if (inputMessages.length === 0) {
-          throw new RuntimeError6(
-            "RILL-R004",
-            "messages list cannot be empty"
-          );
+          throw haltInvalid(ctx, "INVALID_INPUT", "empty_messages", "messages list cannot be empty");
         }
         const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
         const maxTokens = typeof options["max_tokens"] === "number" && options["max_tokens"] > 0 ? options["max_tokens"] : factoryMaxTokens;
@@ -831,21 +993,15 @@ function createGeminiExtension(config) {
         for (let i = 0; i < inputMessages.length; i++) {
           const msg = inputMessages[i];
           if (!msg || typeof msg !== "object" || !("role" in msg)) {
-            throw new RuntimeError6(
-              "RILL-R004",
-              "message missing required 'role' field"
-            );
+            throw haltInvalid(ctx, "INVALID_INPUT", "invalid_message_format", "message missing required 'role' field");
           }
           const role = msg["role"];
           if (role !== "user" && role !== "assistant" && role !== "tool") {
-            throw new RuntimeError6("RILL-R004", `invalid role '${role}'`);
+            throw haltInvalid(ctx, "INVALID_INPUT", "invalid_role", `invalid role '${String(role)}'`);
           }
           if (role === "user" || role === "tool") {
             if (!("content" in msg) || typeof msg["content"] !== "string") {
-              throw new RuntimeError6(
-                "RILL-R004",
-                `${role} message requires 'content'`
-              );
+              throw haltInvalid(ctx, "INVALID_INPUT", "missing_message_content", `${role} message requires 'content'`);
             }
             contents.push({
               role: "user",
@@ -855,10 +1011,7 @@ function createGeminiExtension(config) {
             const hasContent = "content" in msg && msg["content"];
             const hasToolCalls = "tool_calls" in msg && msg["tool_calls"];
             if (!hasContent && !hasToolCalls) {
-              throw new RuntimeError6(
-                "RILL-R004",
-                "assistant message requires 'content' or 'tool_calls'"
-              );
+              throw haltInvalid(ctx, "INVALID_INPUT", "invalid_assistant_message", "assistant message requires 'content' or 'tool_calls'");
             }
             if (hasContent) {
               contents.push({
@@ -897,12 +1050,12 @@ function createGeminiExtension(config) {
               }
             }
           } catch (error) {
-            streamError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+            streamError = error instanceof RuntimeError5 || error instanceof RuntimeHaltSignal3 ? error : mapToHalt(ctx, error);
             const duration = Date.now() - messagesStartTime;
             emitExtensionEvent(ctx, {
               event: "gemini:error",
               subsystem: "extension:gemini",
-              error: streamError.message,
+              error: streamErrorMessage(streamError),
               duration
             });
             throw streamError;
@@ -995,10 +1148,7 @@ function createGeminiExtension(config) {
           });
           const embedding = response.embeddings?.[0];
           if (!embedding || !embedding.values || embedding.values.length === 0) {
-            throw new RuntimeError6(
-              "RILL-R004",
-              "Gemini: empty embedding returned"
-            );
+            throw haltInvalid(ctx, "PROTOCOL", "empty_embedding_response", "Gemini: empty embedding returned");
           }
           const float32Data = new Float32Array(embedding.values);
           const vector = createVector(float32Data, factoryEmbedModel);
@@ -1013,11 +1163,11 @@ function createGeminiExtension(config) {
           return vector;
         } catch (error) {
           const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          const rillError = error instanceof RuntimeError5 || error instanceof RuntimeHaltSignal3 ? error : mapToHalt(ctx, error);
           emitExtensionEvent(ctx, {
             event: "gemini:error",
             subsystem: "extension:gemini",
-            error: rillError.message,
+            error: streamErrorMessage(rillError),
             duration
           });
           throw rillError;
@@ -1044,17 +1194,11 @@ function createGeminiExtension(config) {
           });
           const vectors = [];
           if (!response.embeddings || response.embeddings.length === 0) {
-            throw new RuntimeError6(
-              "RILL-R004",
-              "Gemini: empty embeddings returned"
-            );
+            throw haltInvalid(ctx, "PROTOCOL", "empty_embeddings_response", "Gemini: empty embeddings returned");
           }
           for (const embedding of response.embeddings) {
             if (!embedding || !embedding.values || embedding.values.length === 0) {
-              throw new RuntimeError6(
-                "RILL-R004",
-                "Gemini: empty embedding returned"
-              );
+              throw haltInvalid(ctx, "PROTOCOL", "empty_embedding_response", "Gemini: empty embedding returned");
             }
             const float32Data = new Float32Array(embedding.values);
             const vector = createVector(float32Data, factoryEmbedModel);
@@ -1074,11 +1218,11 @@ function createGeminiExtension(config) {
           return vectors;
         } catch (error) {
           const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          const rillError = error instanceof RuntimeError5 || error instanceof RuntimeHaltSignal3 ? error : mapToHalt(ctx, error);
           emitExtensionEvent(ctx, {
             event: "gemini:error",
             subsystem: "extension:gemini",
-            error: rillError.message,
+            error: streamErrorMessage(rillError),
             duration
           });
           throw rillError;
@@ -1110,7 +1254,7 @@ function createGeminiExtension(config) {
         const toolsDict = args["tools"];
         const options = args["options"] ?? {};
         if (prompt.trim().length === 0) {
-          throw new RuntimeError6("RILL-R004", "prompt text cannot be empty");
+          throw haltInvalid(ctx, "INVALID_INPUT", "empty_prompt", "prompt text cannot be empty");
         }
         const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
         const maxTokens = typeof options["max_tokens"] === "number" && options["max_tokens"] > 0 ? options["max_tokens"] : factoryMaxTokens;
@@ -1309,7 +1453,7 @@ function createGeminiExtension(config) {
             r();
           }
         }).catch((error) => {
-          streamError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          streamError = error instanceof RuntimeError5 || error instanceof RuntimeHaltSignal3 ? error : mapToHalt(ctx, error);
           streamDone = true;
           if (resolveNext) {
             const r = resolveNext;
@@ -1358,7 +1502,7 @@ function createGeminiExtension(config) {
               emitExtensionEvent(ctx, {
                 event: "gemini:error",
                 subsystem: "extension:gemini",
-                error: streamError.message,
+                error: streamErrorMessage(streamError),
                 duration: Date.now()
               });
               return {
@@ -1374,7 +1518,7 @@ function createGeminiExtension(config) {
             emitExtensionEvent(ctx, {
               event: "gemini:error",
               subsystem: "extension:gemini",
-              error: streamError.message,
+              error: streamErrorMessage(streamError),
               duration
             });
             throw streamError;
@@ -1447,16 +1591,10 @@ function createGeminiExtension(config) {
           const schemaArg = args["schema"];
           const options = args["options"] ?? {};
           if (!schemaArg || !schemaArg.__rill_type || !schemaArg.structure) {
-            throw new RuntimeError6(
-              "RILL-R004",
-              "generate requires a type expression as schema"
-            );
+            throw haltInvalid(ctx, "INVALID_INPUT", "invalid_schema", "generate requires a type expression as schema");
           }
           if (schemaArg.structure.kind !== "dict") {
-            throw new RuntimeError6(
-              "RILL-R004",
-              `generate requires a dict type as schema, got ${schemaArg.structure.kind}`
-            );
+            throw haltInvalid(ctx, "INVALID_INPUT", "invalid_schema_type", `generate requires a dict type as schema, got ${schemaArg.structure.kind}`);
           }
           const jsonSchema = buildJsonSchemaFromStructuralType(schemaArg.structure);
           const geminiProperties = {};
@@ -1518,10 +1656,7 @@ function createGeminiExtension(config) {
             data = JSON.parse(raw);
           } catch (parseError) {
             const detail = parseError instanceof Error ? parseError.message : String(parseError);
-            throw new RuntimeError6(
-              "RILL-R004",
-              `generate: failed to parse response JSON: ${detail}`
-            );
+            throw haltInvalid(ctx, "PROTOCOL", "json_parse_failed", `generate: failed to parse response JSON: ${detail}`);
           }
           const inputTokens = response.usageMetadata?.promptTokenCount ?? 0;
           const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0;
@@ -1551,11 +1686,11 @@ function createGeminiExtension(config) {
           return generateResult;
         } catch (error) {
           const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          const rillError = error instanceof RuntimeError5 || error instanceof RuntimeHaltSignal3 ? error : mapToHalt(ctx, error);
           emitExtensionEvent(ctx, {
             event: "gemini:error",
             subsystem: "extension:gemini",
-            error: rillError.message,
+            error: streamErrorMessage(rillError),
             duration
           });
           throw rillError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcrsr/rill-ext-gemini",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "description": "rill extension for Google Gemini API integration",
   "license": "MIT",
   "author": "Andre Bremer",
@@ -17,16 +17,16 @@
     "scripting"
   ],
   "peerDependencies": {
-    "@rcrsr/rill": "~0.18.4"
+    "@rcrsr/rill": "~0.19.0"
   },
   "devDependencies": {
-    "@rcrsr/rill": "~0.18.4",
+    "@rcrsr/rill": "~0.19.0",
     "@types/node": "^25.5.2",
     "dts-bundle-generator": "^9.5.1",
     "tsup": "^8.5.1",
     "undici-types": "^8.0.2",
-    "@rcrsr/rill-ext-llm-shared": "^0.18.4",
-    "@rcrsr/rill-ext-param-shared": "0.18.4"
+    "@rcrsr/rill-ext-param-shared": "0.19.0",
+    "@rcrsr/rill-ext-llm-shared": "^0.19.0"
   },
   "files": [
     "dist"