@rcrsr/rill-ext-openai 0.18.4 → 0.19.1

package/dist/index.js

@@ -4,11 +4,13 @@ import { createRequire } from "module";
 // src/factory.ts
 import OpenAI from "openai";
 import {
-  RuntimeError as RuntimeError6,
+  RuntimeError as RuntimeError5,
+  RuntimeHaltSignal as RuntimeHaltSignal3,
   createRillStream,
   emitExtensionEvent,
   createVector,
   isVector,
+  getStatus as getStatus2,
   structureToTypeValue,
   toCallable
 } from "@rcrsr/rill";
@@ -64,27 +66,137 @@ 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`
+    }
+  });
+}
+function throwProviderHalt(ctx, provider, error, detect) {
+  const invalid = mapProviderError(ctx, provider, error, detect);
+  throw new RuntimeHaltSignal(invalid, true);
 }
 
 // ../../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",
@@ -97,24 +209,24 @@ 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 {};
   }
   if (rillType.kind === "list") {
     const listType = rillType;
-    const property = { type: "array" };
+    const property2 = { type: "array" };
     if (listType.element !== void 0) {
-      property.items = buildPropertyFromStructuralType(listType.element);
+      property2.items = buildPropertyFromStructuralType(listType.element);
     }
-    return property;
+    return property2;
   }
   if (rillType.kind === "dict") {
     const dictType = rillType;
@@ -127,9 +239,14 @@ function buildPropertyFromStructuralType(rillType) {
         additionalProperties: false
       };
     }
-    return { type: "object" };
+    return { type: "object", additionalProperties: false };
+  }
+  const jsonType = mapRillType(rillType.kind);
+  const property = { type: jsonType };
+  if (jsonType === "object") {
+    property.additionalProperties = false;
   }
-  return { type: mapRillType(rillType.kind) };
+  return property;
 }
 function buildDictSchema(dictType) {
   const properties = {};
@@ -153,7 +270,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 = [];
@@ -181,30 +298,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) {
@@ -220,16 +358,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) {
@@ -300,19 +439,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"] ?? "";
@@ -347,7 +486,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;
@@ -361,8 +500,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"];
@@ -419,7 +568,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);
@@ -444,7 +597,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})`);
         }
       }
     }
@@ -471,13 +624,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) {
@@ -603,6 +756,16 @@ var detectOpenAIError = (error) => {
   }
   return null;
 };
+function haltInvalid(ctx, code, rawKind, message) {
+  return new RuntimeHaltSignal3(
+    ctx.invalidate(new Error(message), {
+      code,
+      provider: "openai",
+      raw: { kind: rawKind, message }
+    }),
+    true
+  );
+}
 function createOpenAIExtension(config) {
   validateApiKey(config.api_key);
   validateModel(config.model);
@@ -650,7 +813,7 @@ function createOpenAIExtension(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;
@@ -681,7 +844,7 @@ function createOpenAIExtension(config) {
               }
             }
           } catch (error) {
-            throw mapProviderError("OpenAI", error, detectOpenAIError);
+            throwProviderHalt(ctx, "OpenAI", error, detectOpenAIError);
           }
         }
         const resolve = async () => {
@@ -719,14 +882,23 @@ function createOpenAIExtension(config) {
             return result;
           } catch (error) {
             const duration = Date.now() - startTime;
-            const rillError = mapProviderError("OpenAI", error, detectOpenAIError);
+            if (error instanceof RuntimeHaltSignal3) {
+              emitExtensionEvent(ctx, {
+                event: "openai:error",
+                subsystem: "extension:openai",
+                error: getStatus2(error.value).message,
+                duration
+              });
+              throw error;
+            }
+            const invalid = mapProviderError(ctx, "OpenAI", error, detectOpenAIError);
             emitExtensionEvent(ctx, {
               event: "openai:error",
               subsystem: "extension:openai",
-              error: rillError.message,
+              error: getStatus2(invalid).message,
               duration
             });
-            throw rillError;
+            throw new RuntimeHaltSignal3(invalid, true);
           }
         };
         const retType = {
@@ -780,10 +952,7 @@ function createOpenAIExtension(config) {
         const messages = args["messages"];
         const options = args["options"] ?? {};
         if (messages.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;
@@ -797,21 +966,15 @@ function createOpenAIExtension(config) {
         for (let i = 0; i < messages.length; i++) {
           const msg = messages[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'`);
             }
             apiMessages.push({
               role,
@@ -821,10 +984,7 @@ function createOpenAIExtension(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) {
               apiMessages.push({
@@ -850,7 +1010,7 @@ function createOpenAIExtension(config) {
               }
             }
           } catch (error) {
-            throw mapProviderError("OpenAI", error, detectOpenAIError);
+            throwProviderHalt(ctx, "OpenAI", error, detectOpenAIError);
           }
         }
         const resolve = async () => {
@@ -888,14 +1048,23 @@ function createOpenAIExtension(config) {
             return result;
           } catch (error) {
             const duration = Date.now() - startTime;
-            const rillError = mapProviderError("OpenAI", error, detectOpenAIError);
+            if (error instanceof RuntimeHaltSignal3) {
+              emitExtensionEvent(ctx, {
+                event: "openai:error",
+                subsystem: "extension:openai",
+                error: getStatus2(error.value).message,
+                duration
+              });
+              throw error;
+            }
+            const invalid = mapProviderError(ctx, "OpenAI", error, detectOpenAIError);
             emitExtensionEvent(ctx, {
               event: "openai:error",
               subsystem: "extension:openai",
-              error: rillError.message,
+              error: getStatus2(invalid).message,
               duration
             });
-            throw rillError;
+            throw new RuntimeHaltSignal3(invalid, true);
           }
         };
         const retType = {
@@ -952,10 +1121,7 @@ function createOpenAIExtension(config) {
           });
           const embeddingData = response.data[0]?.embedding;
           if (!embeddingData || embeddingData.length === 0) {
-            throw new RuntimeError6(
-              "RILL-R004",
-              "OpenAI: empty embedding returned"
-            );
+            throw haltInvalid(ctx, "PROTOCOL", "empty_embedding_response", "OpenAI: empty embedding returned");
           }
           const float32Data = new Float32Array(embeddingData);
           const vector = createVector(float32Data, factoryEmbedModel);
@@ -970,7 +1136,17 @@ function createOpenAIExtension(config) {
           return vector;
         } catch (error) {
           const duration = Date.now() - startTime;
-          const rillError = mapProviderError(
+          if (error instanceof RuntimeHaltSignal3) {
+            emitExtensionEvent(ctx, {
+              event: "openai:error",
+              subsystem: "extension:openai",
+              error: getStatus2(error.value).message,
+              duration
+            });
+            throw error;
+          }
+          const invalid = mapProviderError(
+            ctx,
             "OpenAI",
             error,
             detectOpenAIError
@@ -978,10 +1154,10 @@ function createOpenAIExtension(config) {
           emitExtensionEvent(ctx, {
             event: "openai:error",
             subsystem: "extension:openai",
-            error: rillError.message,
+            error: getStatus2(invalid).message,
             duration
           });
-          throw rillError;
+          throw new RuntimeHaltSignal3(invalid, true);
         }
       },
       annotations: { description: "Generate embedding vector for text" },
@@ -1008,10 +1184,7 @@ function createOpenAIExtension(config) {
           for (const embeddingItem of response.data) {
             const embeddingData = embeddingItem.embedding;
             if (!embeddingData || embeddingData.length === 0) {
-              throw new RuntimeError6(
-                "RILL-R004",
-                "OpenAI: empty embedding returned"
-              );
+              throw haltInvalid(ctx, "PROTOCOL", "empty_embedding_response", "OpenAI: empty embedding returned");
             }
             const float32Data = new Float32Array(embeddingData);
             const vector = createVector(float32Data, factoryEmbedModel);
@@ -1031,7 +1204,17 @@ function createOpenAIExtension(config) {
           return vectors;
         } catch (error) {
           const duration = Date.now() - startTime;
-          const rillError = mapProviderError(
+          if (error instanceof RuntimeHaltSignal3) {
+            emitExtensionEvent(ctx, {
+              event: "openai:error",
+              subsystem: "extension:openai",
+              error: getStatus2(error.value).message,
+              duration
+            });
+            throw error;
+          }
+          const invalid = mapProviderError(
+            ctx,
             "OpenAI",
             error,
             detectOpenAIError
@@ -1039,10 +1222,10 @@ function createOpenAIExtension(config) {
           emitExtensionEvent(ctx, {
             event: "openai:error",
             subsystem: "extension:openai",
-            error: rillError.message,
+            error: getStatus2(invalid).message,
             duration
           });
-          throw rillError;
+          throw new RuntimeHaltSignal3(invalid, true);
         }
       },
       annotations: { description: "Generate embedding vectors for multiple texts" },
@@ -1071,7 +1254,7 @@ function createOpenAIExtension(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;
@@ -1088,20 +1271,14 @@ function createOpenAIExtension(config) {
           const prependedMessages = options["messages"];
           for (const msg of prependedMessages) {
             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") {
-              throw new RuntimeError6("RILL-R004", `invalid role '${role}'`);
+              throw haltInvalid(ctx, "INVALID_INPUT", "invalid_role", `invalid role '${String(role)}'`);
             }
             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'`);
             }
             messages.push({
               role,
@@ -1278,8 +1455,8 @@ function createOpenAIExtension(config) {
               yield chunk;
             }
           } catch (error) {
-            const rillError = mapProviderError("OpenAI", error, detectOpenAIError);
-            throw rillError;
+            if (error instanceof RuntimeHaltSignal3) throw error;
+            throwProviderHalt(ctx, "OpenAI", error, detectOpenAIError);
           }
         }
         const resolve = async () => {
@@ -1320,14 +1497,23 @@ function createOpenAIExtension(config) {
             return result;
           } catch (error) {
             const duration = Date.now() - startTime;
-            const rillError = mapProviderError("OpenAI", error, detectOpenAIError);
+            if (error instanceof RuntimeHaltSignal3) {
+              emitExtensionEvent(ctx, {
+                event: "openai:error",
+                subsystem: "extension:openai",
+                error: getStatus2(error.value).message,
+                duration
+              });
+              throw error;
+            }
+            const invalid = mapProviderError(ctx, "OpenAI", error, detectOpenAIError);
             emitExtensionEvent(ctx, {
               event: "openai:error",
               subsystem: "extension:openai",
-              error: rillError.message,
+              error: getStatus2(invalid).message,
               duration
             });
-            throw rillError;
+            throw new RuntimeHaltSignal3(invalid, true);
           }
         };
         const retType = {
@@ -1386,16 +1572,10 @@ function createOpenAIExtension(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 system = typeof options["system"] === "string" ? options["system"] : factorySystem;
@@ -1411,20 +1591,14 @@ function createOpenAIExtension(config) {
             const prependedMessages = options["messages"];
             for (const msg of prependedMessages) {
               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") {
-                throw new RuntimeError6("RILL-R004", `invalid role '${role}'`);
+                throw haltInvalid(ctx, "INVALID_INPUT", "invalid_role", `invalid role '${String(role)}'`);
               }
               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'`);
               }
               apiMessages.push({
                 role,
@@ -1456,10 +1630,7 @@ function createOpenAIExtension(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 result = {
             data,
@@ -1485,14 +1656,32 @@ function createOpenAIExtension(config) {
           return result;
         } catch (error) {
           const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("OpenAI", error, detectOpenAIError);
+          if (error instanceof RuntimeError5) {
+            emitExtensionEvent(ctx, {
+              event: "openai:error",
+              subsystem: "extension:openai",
+              error: error.message,
+              duration
+            });
+            throw error;
+          }
+          if (error instanceof RuntimeHaltSignal3) {
+            emitExtensionEvent(ctx, {
+              event: "openai:error",
+              subsystem: "extension:openai",
+              error: getStatus2(error.value).message,
+              duration
+            });
+            throw error;
+          }
+          const invalid = mapProviderError(ctx, "OpenAI", error, detectOpenAIError);
           emitExtensionEvent(ctx, {
             event: "openai:error",
             subsystem: "extension:openai",
-            error: rillError.message,
+            error: getStatus2(invalid).message,
             duration
           });
-          throw rillError;
+          throw new RuntimeHaltSignal3(invalid, true);
         }
       },
       annotations: { description: "Generate structured output from OpenAI API" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcrsr/rill-ext-openai",
-  "version": "0.18.4",
+  "version": "0.19.1",
   "description": "rill extension for OpenAI 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-llm-shared": "^0.19.0",
+    "@rcrsr/rill-ext-param-shared": "0.19.0"
   },
   "files": [
     "dist"