@rcrsr/rill-ext-openai 0.8.3 → 0.8.5

package/dist/index.js

@@ -1,14 +1,940 @@
-/**
- * @rcrsr/rill-ext-openai
- *
- * Extension for OpenAI API integration with rill scripts.
- */
-// ============================================================
-// VERSION
-// ============================================================
-export const VERSION = '0.0.1';
-// ============================================================
-// EXTENSION FACTORY
-// ============================================================
-export { createOpenAIExtension } from './factory.js';
-//# sourceMappingURL=index.js.map
+// src/factory.ts
+import OpenAI from "openai";
+import {
+  RuntimeError as RuntimeError4,
+  emitExtensionEvent,
+  createVector,
+  isCallable as isCallable2,
+  isVector
+} from "@rcrsr/rill";
+
+// ../../shared/ext-llm/dist/validation.js
+import { RuntimeError } from "@rcrsr/rill";
+var MIN_TEMPERATURE = 0;
+var MAX_TEMPERATURE = 2;
+function validateApiKey(key) {
+  if (key === void 0) {
+    throw new Error("api_key is required");
+  }
+  if (key === "") {
+    throw new Error("api_key cannot be empty");
+  }
+}
+function validateModel(model) {
+  if (!model) {
+    throw new Error("model is required");
+  }
+}
+function validateTemperature(temperature) {
+  if (temperature === void 0) {
+    return;
+  }
+  if (temperature < MIN_TEMPERATURE || temperature > MAX_TEMPERATURE) {
+    throw new Error("temperature must be between 0 and 2");
+  }
+}
+function validateEmbedText(text) {
+  if (text === "") {
+    throw new RuntimeError("RILL-R001", "embed text cannot be empty");
+  }
+}
+function validateEmbedBatch(texts) {
+  const validated = [];
+  for (let i = 0; i < texts.length; i++) {
+    const item = texts[i];
+    if (typeof item !== "string") {
+      throw new RuntimeError("RILL-R001", "embed_batch requires list of strings");
+    }
+    if (item === "") {
+      throw new RuntimeError("RILL-R001", `embed text cannot be empty at index ${i}`);
+    }
+    validated.push(item);
+  }
+  return validated;
+}
+function validateEmbedModel(model) {
+  if (!model) {
+    throw new RuntimeError("RILL-R001", "embed_model not configured");
+  }
+}
+
+// ../../shared/ext-llm/dist/errors.js
+import { RuntimeError as RuntimeError2 } from "@rcrsr/rill";
+function mapProviderError(providerName, error, detect) {
+  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 new RuntimeError2("RILL-R004", `${providerName} API error: ${message}`, void 0, { cause: error });
+  }
+  if (error instanceof Error) {
+    return new RuntimeError2("RILL-R004", `${providerName} error: ${error.message}`, void 0, { cause: error });
+  }
+  return new RuntimeError2("RILL-R004", `${providerName} error: Unknown error`, void 0, { cause: error });
+}
+
+// ../../shared/ext-llm/dist/tool-loop.js
+import { isCallable, isDict, RuntimeError as RuntimeError3 } from "@rcrsr/rill";
+async function executeToolCall(toolName, toolInput, tools, context) {
+  if (!isDict(tools)) {
+    throw new RuntimeError3("RILL-R004", "tools must be a dict mapping tool names to functions");
+  }
+  const toolsDict = tools;
+  const toolFn = toolsDict[toolName];
+  if (toolFn === void 0 || toolFn === null) {
+    throw new RuntimeError3("RILL-R004", `Unknown tool: ${toolName}`);
+  }
+  if (!isCallable(toolFn)) {
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: tool must be callable`);
+  }
+  if (typeof toolInput !== "object" || toolInput === null) {
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: input must be an object`);
+  }
+  const callable = toolFn;
+  if (callable.kind !== "runtime" && callable.kind !== "application") {
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: tool must be application or runtime callable`);
+  }
+  try {
+    let args;
+    if (callable.kind === "application" && callable.params) {
+      const params = callable.params;
+      const inputDict = toolInput;
+      args = params.map((param) => {
+        const value = inputDict[param.name];
+        return value !== void 0 ? value : void 0;
+      });
+    } else {
+      args = [toolInput];
+    }
+    const ctx = context ?? {
+      parent: void 0,
+      variables: /* @__PURE__ */ new Map(),
+      pipeValue: null
+    };
+    const result = callable.fn(args, ctx);
+    return result instanceof Promise ? await result : result;
+  } catch (error) {
+    if (error instanceof RuntimeError3) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: ${message}`);
+  }
+}
+async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent, maxTurns = 10, context) {
+  if (tools === void 0) {
+    throw new RuntimeError3("RILL-R004", "tools parameter is required");
+  }
+  if (!isDict(tools)) {
+    throw new RuntimeError3("RILL-R004", "tools must be a dict mapping tool names to functions");
+  }
+  const toolsDict = tools;
+  const toolDescriptors = Object.entries(toolsDict).map(([name, fn]) => {
+    const fnValue = fn;
+    if (!isCallable(fnValue)) {
+      throw new RuntimeError3("RILL-R004", `tool '${name}' must be callable function`);
+    }
+    const callable = fnValue;
+    const description = callable.kind === "application" && callable.description ? callable.description : "";
+    const properties = {};
+    const required = [];
+    if (callable.kind === "application" && callable.params) {
+      for (const param of callable.params) {
+        let jsonSchemaType;
+        switch (param.typeName) {
+          case "string":
+            jsonSchemaType = "string";
+            break;
+          case "number":
+            jsonSchemaType = "number";
+            break;
+          case "bool":
+            jsonSchemaType = "boolean";
+            break;
+          case "list":
+            jsonSchemaType = "array";
+            break;
+          case "dict":
+          case "vector":
+            jsonSchemaType = "object";
+            break;
+          case null:
+            jsonSchemaType = "string";
+            break;
+        }
+        const property = {
+          type: jsonSchemaType
+        };
+        if (param.description) {
+          property["description"] = param.description;
+        }
+        properties[param.name] = property;
+        if (param.defaultValue === null) {
+          required.push(param.name);
+        }
+      }
+    }
+    return {
+      name,
+      description,
+      input_schema: {
+        type: "object",
+        properties,
+        required
+      }
+    };
+  });
+  const providerTools = callbacks.buildTools(toolDescriptors);
+  let consecutiveErrors = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const executedToolCalls = [];
+  let currentMessages = [...messages];
+  let turnCount = 0;
+  while (turnCount < maxTurns) {
+    turnCount++;
+    let response;
+    try {
+      response = await callbacks.callAPI(currentMessages, providerTools);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new RuntimeError3("RILL-R004", `Provider API error: ${message}`, void 0, { cause: error });
+    }
+    if (typeof response === "object" && response !== null && "usage" in response) {
+      const usage = response["usage"];
+      if (typeof usage === "object" && usage !== null) {
+        const usageRecord = usage;
+        const inputTokens = typeof usageRecord["input_tokens"] === "number" ? usageRecord["input_tokens"] : 0;
+        const outputTokens = typeof usageRecord["output_tokens"] === "number" ? usageRecord["output_tokens"] : 0;
+        totalInputTokens += inputTokens;
+        totalOutputTokens += outputTokens;
+      }
+    }
+    const toolCalls = callbacks.extractToolCalls(response);
+    if (toolCalls === null || toolCalls.length === 0) {
+      return {
+        response,
+        toolCalls: executedToolCalls,
+        totalTokens: { input: totalInputTokens, output: totalOutputTokens },
+        turns: turnCount
+      };
+    }
+    const toolResults = [];
+    for (const toolCall of toolCalls) {
+      const { id, name, input } = toolCall;
+      emitEvent("tool_call", { tool_name: name, args: input });
+      const toolStartTime = Date.now();
+      try {
+        const result = await executeToolCall(name, input, tools, context);
+        const duration = Date.now() - toolStartTime;
+        toolResults.push({ id, name, result });
+        executedToolCalls.push({ name, result });
+        consecutiveErrors = 0;
+        emitEvent("tool_result", { tool_name: name, duration });
+      } catch (error) {
+        const duration = Date.now() - toolStartTime;
+        consecutiveErrors++;
+        let originalError;
+        if (error instanceof RuntimeError3) {
+          const prefix = `Invalid tool input for ${name}: `;
+          if (error.message.startsWith(prefix)) {
+            originalError = error.message.slice(prefix.length);
+          } else {
+            originalError = error.message;
+          }
+        } else if (error instanceof Error) {
+          originalError = error.message;
+        } else {
+          originalError = "Unknown error";
+        }
+        const errorResult = originalError;
+        toolResults.push({
+          id,
+          name,
+          result: errorResult,
+          error: originalError
+        });
+        emitEvent("tool_result", {
+          tool_name: name,
+          error: originalError,
+          duration
+        });
+        if (consecutiveErrors >= maxErrors) {
+          throw new RuntimeError3("RILL-R004", `Tool execution failed: ${maxErrors} consecutive errors`);
+        }
+      }
+    }
+    const toolResultMessage = callbacks.formatToolResult(toolResults);
+    currentMessages.push(toolResultMessage);
+  }
+  return {
+    response: null,
+    toolCalls: executedToolCalls,
+    totalTokens: { input: totalInputTokens, output: totalOutputTokens },
+    turns: turnCount
+  };
+}
+
+// src/factory.ts
+var DEFAULT_MAX_TOKENS = 4096;
+var detectOpenAIError = (error) => {
+  if (error instanceof OpenAI.APIError) {
+    return {
+      status: error.status ?? void 0,
+      message: error.message
+    };
+  }
+  return null;
+};
+function createOpenAIExtension(config) {
+  validateApiKey(config.api_key);
+  validateModel(config.model);
+  validateTemperature(config.temperature);
+  const client = new OpenAI({
+    apiKey: config.api_key,
+    baseURL: config.base_url,
+    maxRetries: config.max_retries,
+    timeout: config.timeout
+  });
+  const factoryModel = config.model;
+  const factoryTemperature = config.temperature;
+  const factoryMaxTokens = config.max_tokens ?? DEFAULT_MAX_TOKENS;
+  const factorySystem = config.system;
+  const factoryEmbedModel = config.embed_model;
+  void factoryEmbedModel;
+  let abortController = new AbortController();
+  const dispose = async () => {
+    try {
+      if (abortController) {
+        abortController.abort();
+        abortController = void 0;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`Failed to abort OpenAI requests: ${message}`);
+    }
+    try {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`Failed to cleanup OpenAI SDK: ${message}`);
+    }
+  };
+  const result = {
+    // IR-4: openai::message
+    message: {
+      params: [
+        { name: "text", type: "string" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const text = args[0];
+          const options = args[1] ?? {};
+          if (text.trim().length === 0) {
+            throw new RuntimeError4("RILL-R004", "prompt text cannot be empty");
+          }
+          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
+          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const apiMessages = [];
+          if (system !== void 0) {
+            apiMessages.push({
+              role: "system",
+              content: system
+            });
+          }
+          apiMessages.push({
+            role: "user",
+            content: text
+          });
+          const apiParams = {
+            model: factoryModel,
+            max_tokens: maxTokens,
+            messages: apiMessages
+          };
+          if (factoryTemperature !== void 0) {
+            apiParams.temperature = factoryTemperature;
+          }
+          const response = await client.chat.completions.create(apiParams);
+          const content = response.choices[0]?.message?.content ?? "";
+          const result2 = {
+            content,
+            model: response.model,
+            usage: {
+              input: response.usage?.prompt_tokens ?? 0,
+              output: response.usage?.completion_tokens ?? 0
+            },
+            stop_reason: response.choices[0]?.finish_reason ?? "unknown",
+            id: response.id,
+            messages: [
+              ...system ? [{ role: "system", content: system }] : [],
+              { role: "user", content: text },
+              { role: "assistant", content }
+            ]
+          };
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "openai:message",
+            subsystem: "extension:openai",
+            duration,
+            model: response.model,
+            usage: result2.usage
+          });
+          return result2;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapProviderError(
+            "OpenAI",
+            error,
+            detectOpenAIError
+          );
+          emitExtensionEvent(ctx, {
+            event: "openai:error",
+            subsystem: "extension:openai",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Send single message to OpenAI API",
+      returnType: "dict"
+    },
+    // IR-5: openai::messages
+    messages: {
+      params: [
+        { name: "messages", type: "list" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const messages = args[0];
+          const options = args[1] ?? {};
+          if (messages.length === 0) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "messages list cannot be empty"
+            );
+          }
+          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
+          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const apiMessages = [];
+          if (system !== void 0) {
+            apiMessages.push({
+              role: "system",
+              content: system
+            });
+          }
+          for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg || typeof msg !== "object" || !("role" in msg)) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "message missing required 'role' field"
+              );
+            }
+            const role = msg["role"];
+            if (role !== "user" && role !== "assistant" && role !== "tool") {
+              throw new RuntimeError4("RILL-R004", `invalid role '${role}'`);
+            }
+            if (role === "user" || role === "tool") {
+              if (!("content" in msg) || typeof msg["content"] !== "string") {
+                throw new RuntimeError4(
+                  "RILL-R004",
+                  `${role} message requires 'content'`
+                );
+              }
+              apiMessages.push({
+                role,
+                content: msg["content"]
+              });
+            } else if (role === "assistant") {
+              const hasContent = "content" in msg && msg["content"];
+              const hasToolCalls = "tool_calls" in msg && msg["tool_calls"];
+              if (!hasContent && !hasToolCalls) {
+                throw new RuntimeError4(
+                  "RILL-R004",
+                  "assistant message requires 'content' or 'tool_calls'"
+                );
+              }
+              if (hasContent) {
+                apiMessages.push({
+                  role: "assistant",
+                  content: msg["content"]
+                });
+              }
+            }
+          }
+          const apiParams = {
+            model: factoryModel,
+            max_tokens: maxTokens,
+            messages: apiMessages
+          };
+          if (factoryTemperature !== void 0) {
+            apiParams.temperature = factoryTemperature;
+          }
+          const response = await client.chat.completions.create(apiParams);
+          const content = response.choices[0]?.message?.content ?? "";
+          const fullMessages = [
+            ...messages.map((m) => {
+              const normalized = { role: m["role"] };
+              if ("content" in m) normalized["content"] = m["content"];
+              if ("tool_calls" in m) normalized["tool_calls"] = m["tool_calls"];
+              return normalized;
+            }),
+            { role: "assistant", content }
+          ];
+          const result2 = {
+            content,
+            model: response.model,
+            usage: {
+              input: response.usage?.prompt_tokens ?? 0,
+              output: response.usage?.completion_tokens ?? 0
+            },
+            stop_reason: response.choices[0]?.finish_reason ?? "unknown",
+            id: response.id,
+            messages: fullMessages
+          };
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "openai:messages",
+            subsystem: "extension:openai",
+            duration,
+            model: response.model,
+            usage: result2.usage
+          });
+          return result2;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapProviderError(
+            "OpenAI",
+            error,
+            detectOpenAIError
+          );
+          emitExtensionEvent(ctx, {
+            event: "openai:error",
+            subsystem: "extension:openai",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Send multi-turn conversation to OpenAI API",
+      returnType: "dict"
+    },
+    // IR-6: openai::embed
+    embed: {
+      params: [{ name: "text", type: "string" }],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const text = args[0];
+          validateEmbedText(text.trim());
+          validateEmbedModel(factoryEmbedModel);
+          const response = await client.embeddings.create({
+            model: factoryEmbedModel,
+            input: text,
+            encoding_format: "float"
+          });
+          const embeddingData = response.data[0]?.embedding;
+          if (!embeddingData || embeddingData.length === 0) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "OpenAI: empty embedding returned"
+            );
+          }
+          const float32Data = new Float32Array(embeddingData);
+          const vector = createVector(float32Data, factoryEmbedModel);
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "openai:embed",
+            subsystem: "extension:openai",
+            duration,
+            model: factoryEmbedModel,
+            dimensions: float32Data.length
+          });
+          return vector;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapProviderError(
+            "OpenAI",
+            error,
+            detectOpenAIError
+          );
+          emitExtensionEvent(ctx, {
+            event: "openai:error",
+            subsystem: "extension:openai",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Generate embedding vector for text",
+      returnType: "vector"
+    },
+    // IR-7: openai::embed_batch
+    embed_batch: {
+      params: [{ name: "texts", type: "list" }],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const texts = args[0];
+          if (texts.length === 0) {
+            return [];
+          }
+          validateEmbedModel(factoryEmbedModel);
+          const stringTexts = validateEmbedBatch(texts);
+          const response = await client.embeddings.create({
+            model: factoryEmbedModel,
+            input: stringTexts,
+            encoding_format: "float"
+          });
+          const vectors = [];
+          for (const embeddingItem of response.data) {
+            const embeddingData = embeddingItem.embedding;
+            if (!embeddingData || embeddingData.length === 0) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "OpenAI: empty embedding returned"
+              );
+            }
+            const float32Data = new Float32Array(embeddingData);
+            const vector = createVector(float32Data, factoryEmbedModel);
+            vectors.push(vector);
+          }
+          const duration = Date.now() - startTime;
+          const firstVector = vectors[0];
+          const dimensions = firstVector && isVector(firstVector) ? firstVector.data.length : 0;
+          emitExtensionEvent(ctx, {
+            event: "openai:embed_batch",
+            subsystem: "extension:openai",
+            duration,
+            model: factoryEmbedModel,
+            dimensions,
+            count: vectors.length
+          });
+          return vectors;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapProviderError(
+            "OpenAI",
+            error,
+            detectOpenAIError
+          );
+          emitExtensionEvent(ctx, {
+            event: "openai:error",
+            subsystem: "extension:openai",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Generate embedding vectors for multiple texts",
+      returnType: "list"
+    },
+    // IR-8: openai::tool_loop
+    tool_loop: {
+      params: [
+        { name: "prompt", type: "string" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const prompt = args[0];
+          const options = args[1] ?? {};
+          if (prompt.trim().length === 0) {
+            throw new RuntimeError4("RILL-R004", "prompt text cannot be empty");
+          }
+          if (!("tools" in options) || !Array.isArray(options["tools"])) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "tool_loop requires 'tools' option"
+            );
+          }
+          const toolDescriptors = options["tools"];
+          const toolsDict = {};
+          for (const descriptor of toolDescriptors) {
+            const name = typeof descriptor["name"] === "string" ? descriptor["name"] : null;
+            if (!name) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "tool descriptor missing name"
+              );
+            }
+            const toolFnValue = descriptor["fn"];
+            if (!toolFnValue) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                `tool '${name}' missing fn property`
+              );
+            }
+            if (!isCallable2(toolFnValue)) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                `tool '${name}' fn must be callable`
+              );
+            }
+            const paramsObj = descriptor["params"];
+            const description = typeof descriptor["description"] === "string" ? descriptor["description"] : "";
+            let enhancedCallable = toolFnValue;
+            if (paramsObj && typeof paramsObj === "object" && !Array.isArray(paramsObj)) {
+              const params = Object.entries(
+                paramsObj
+              ).map(([paramName, paramMeta]) => {
+                const meta = paramMeta;
+                const typeStr = typeof meta["type"] === "string" ? meta["type"] : null;
+                let typeName = null;
+                if (typeStr === "string") typeName = "string";
+                else if (typeStr === "number") typeName = "number";
+                else if (typeStr === "bool" || typeStr === "boolean")
+                  typeName = "bool";
+                else if (typeStr === "list" || typeStr === "array")
+                  typeName = "list";
+                else if (typeStr === "dict" || typeStr === "object")
+                  typeName = "dict";
+                else if (typeStr === "vector") typeName = "vector";
+                const param = {
+                  name: paramName,
+                  typeName,
+                  defaultValue: null,
+                  annotations: {}
+                };
+                if (typeof meta["description"] === "string") {
+                  param.description = meta["description"];
+                }
+                return param;
+              });
+              const baseCallable = toolFnValue;
+              enhancedCallable = {
+                __type: "callable",
+                kind: "application",
+                params,
+                fn: baseCallable.fn,
+                description,
+                isProperty: baseCallable.isProperty ?? false
+              };
+            }
+            toolsDict[name] = enhancedCallable;
+          }
+          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
+          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const maxErrors = typeof options["max_errors"] === "number" ? options["max_errors"] : 3;
+          const maxTurns = typeof options["max_turns"] === "number" ? options["max_turns"] : 10;
+          const messages = [];
+          if (system !== void 0) {
+            messages.push({
+              role: "system",
+              content: system
+            });
+          }
+          if ("messages" in options && Array.isArray(options["messages"])) {
+            const prependedMessages = options["messages"];
+            for (const msg of prependedMessages) {
+              if (!msg || typeof msg !== "object" || !("role" in msg)) {
+                throw new RuntimeError4(
+                  "RILL-R004",
+                  "message missing required 'role' field"
+                );
+              }
+              const role = msg["role"];
+              if (role !== "user" && role !== "assistant") {
+                throw new RuntimeError4("RILL-R004", `invalid role '${role}'`);
+              }
+              if (!("content" in msg) || typeof msg["content"] !== "string") {
+                throw new RuntimeError4(
+                  "RILL-R004",
+                  `${role} message requires 'content'`
+                );
+              }
+              messages.push({
+                role,
+                content: msg["content"]
+              });
+            }
+          }
+          messages.push({
+            role: "user",
+            content: prompt
+          });
+          const callbacks = {
+            // Build OpenAI Tool format from tool definitions
+            buildTools: (toolDefs) => {
+              return toolDefs.map((def) => ({
+                type: "function",
+                function: {
+                  name: def.name,
+                  description: def.description,
+                  parameters: def.input_schema
+                }
+              }));
+            },
+            // Call OpenAI API
+            callAPI: async (msgs, tools) => {
+              const apiParams = {
+                model: factoryModel,
+                max_tokens: maxTokens,
+                messages: msgs,
+                tools,
+                tool_choice: "auto"
+              };
+              if (factoryTemperature !== void 0) {
+                apiParams.temperature = factoryTemperature;
+              }
+              const response2 = await client.chat.completions.create(apiParams);
+              return {
+                ...response2,
+                usage: {
+                  input_tokens: response2.usage?.prompt_tokens ?? 0,
+                  output_tokens: response2.usage?.completion_tokens ?? 0
+                }
+              };
+            },
+            // Extract tool calls from OpenAI response
+            extractToolCalls: (response2) => {
+              if (!response2 || typeof response2 !== "object" || !("choices" in response2)) {
+                return null;
+              }
+              const choices = response2.choices;
+              if (!Array.isArray(choices) || choices.length === 0) {
+                return null;
+              }
+              const choice = choices[0];
+              if (!choice || typeof choice !== "object" || !("message" in choice)) {
+                return null;
+              }
+              const message = choice.message;
+              if (!message || typeof message !== "object" || !("tool_calls" in message)) {
+                return null;
+              }
+              const toolCalls = message.tool_calls;
+              if (!toolCalls || !Array.isArray(toolCalls)) {
+                return null;
+              }
+              const functionToolCalls = toolCalls.filter(
+                (tc) => typeof tc === "object" && tc !== null && "type" in tc && tc.type === "function"
+              );
+              return functionToolCalls.map((tc) => {
+                const functionCall = tc;
+                const args2 = functionCall.function.arguments;
+                let parsedArgs;
+                try {
+                  parsedArgs = JSON.parse(args2);
+                } catch {
+                  parsedArgs = {};
+                }
+                return {
+                  id: tc.id,
+                  name: functionCall.function.name,
+                  input: parsedArgs
+                };
+              });
+            },
+            // Format tool results into OpenAI message format
+            formatToolResult: (toolResults) => {
+              return toolResults.map((tr) => ({
+                role: "tool",
+                tool_call_id: tr.id,
+                content: tr.error ? JSON.stringify({ error: tr.error, code: "RILL-R001" }) : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
+              }));
+            }
+          };
+          const loopResult = await executeToolLoop(
+            messages,
+            toolsDict,
+            maxErrors,
+            callbacks,
+            (event, data) => {
+              const eventMap = {
+                tool_call: "openai:tool_call",
+                tool_result: "openai:tool_result"
+              };
+              emitExtensionEvent(ctx, {
+                event: eventMap[event] || event,
+                subsystem: "extension:openai",
+                ...data
+              });
+            },
+            maxTurns,
+            ctx
+          );
+          const response = loopResult.response;
+          const content = response?.choices[0]?.message?.content ?? "";
+          const stopReason = loopResult.turns >= maxTurns ? "max_turns" : response?.choices[0]?.finish_reason ?? "stop";
+          const fullMessages = [];
+          for (const msg of messages) {
+            if ("role" in msg && msg.role !== "system") {
+              const historyMsg = {
+                role: msg.role
+              };
+              if ("content" in msg && msg.content) {
+                historyMsg["content"] = msg.content;
+              }
+              if ("tool_calls" in msg && msg.tool_calls) {
+                historyMsg["tool_calls"] = msg.tool_calls;
+              }
+              fullMessages.push(historyMsg);
+            }
+          }
+          if (response) {
+            fullMessages.push({
+              role: "assistant",
+              content
+            });
+          }
+          const result2 = {
+            content,
+            model: factoryModel,
+            usage: {
+              input: loopResult.totalTokens.input,
+              output: loopResult.totalTokens.output
+            },
+            stop_reason: stopReason,
+            turns: loopResult.turns,
+            messages: fullMessages
+          };
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "openai:tool_loop",
+            subsystem: "extension:openai",
+            turns: loopResult.turns,
+            total_duration: duration,
+            usage: result2.usage
+          });
+          return result2;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = mapProviderError(
+            "OpenAI",
+            error,
+            detectOpenAIError
+          );
+          emitExtensionEvent(ctx, {
+            event: "openai:error",
+            subsystem: "extension:openai",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Execute tool-use loop with OpenAI API",
+      returnType: "dict"
+    }
+  };
+  result.dispose = dispose;
+  return result;
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  VERSION,
+  createOpenAIExtension
+};