@rcrsr/rill-ext-gemini 0.16.0 → 0.18.1

package/dist/index.js

@@ -9,10 +9,11 @@ import {
 import {
   RuntimeError as RuntimeError6,
   emitExtensionEvent,
+  createRillStream,
   createVector,
   isVector,
-  isDict as isDict2,
-  rillTypeToTypeValue
+  structureToTypeValue,
+  toCallable
 } from "@rcrsr/rill";
 
 // ../../shared/ext-llm/dist/validation.js
@@ -52,7 +53,7 @@ function validateEmbedBatch(texts) {
     if (typeof item !== "string") {
       throw new RuntimeError("RILL-R001", "embed_batch requires list of strings");
     }
-    if (item === "") {
+    if (item.trim() === "") {
       throw new RuntimeError("RILL-R001", `embed text cannot be empty at index ${i}`);
     }
     validated.push(item);
@@ -104,28 +105,29 @@ function mapRillType(rillType) {
   return jsonType;
 }
 function buildPropertyFromStructuralType(rillType) {
-  if (rillType.type === "closure" || rillType.type === "tuple") {
-    throw new RuntimeError3("RILL-R004", `unsupported type for JSON Schema: ${rillType.type}`);
+  if (rillType.kind === "closure" || rillType.kind === "tuple") {
+    throw new RuntimeError3("RILL-R004", `unsupported type for JSON Schema: ${rillType.kind}`);
   }
-  if (rillType.type === "any") {
+  if (rillType.kind === "any") {
     return {};
   }
-  if (rillType.type === "list") {
+  if (rillType.kind === "list") {
+    const listType = rillType;
     const property = { type: "array" };
-    if (rillType.element !== void 0) {
-      property.items = buildPropertyFromStructuralType(rillType.element);
+    if (listType.element !== void 0) {
+      property.items = buildPropertyFromStructuralType(listType.element);
     }
     return property;
   }
-  if (rillType.type === "dict") {
+  if (rillType.kind === "dict") {
     return { type: "object" };
   }
-  return { type: mapRillType(rillType.type) };
+  return { type: mapRillType(rillType.kind) };
 }
 function buildJsonSchemaFromStructuralType(type, params) {
   const properties = {};
   const required = [];
-  if (type.type === "closure") {
+  if (type.kind === "closure") {
     const closureParams = type.params ?? [];
     for (let i = 0; i < closureParams.length; i++) {
       const fieldDef = closureParams[i];
@@ -241,7 +243,7 @@ async function executeToolCall(toolName, toolInput, tools, context) {
           return value !== void 0 ? value : void 0;
         });
       } else {
-        args = [inputDict];
+        args = [];
       }
       return await invokeCallable(callable, args, context);
     }
@@ -326,7 +328,7 @@ function patchResponseToolCallNames(response, nameMap) {
     }
   }
 }
-async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent, maxTurns = 10, context) {
+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");
   }
@@ -348,8 +350,8 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
     const params = callable.kind === "application" ? callable.params ?? [] : callable.kind === "script" ? callable.params : [];
     if (params.length > 0) {
       const closureType = {
-        type: "closure",
-        params: params.map((p2) => ({ name: p2.name, type: p2.type ?? { type: "any" } }))
+        kind: "closure",
+        params: params.map((p2) => ({ name: p2.name, type: p2.type ?? { kind: "any" } }))
       };
       const builtSchema = buildJsonSchemaFromStructuralType(closureType, [...params]);
       inputSchema = {
@@ -374,10 +376,20 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
   let currentMessages = [...messages];
   let turnCount = 0;
   while (turnCount < maxTurns) {
+    if (signal?.aborted) {
+      throw new RuntimeError4("RILL-R004", "tool_loop cancelled");
+    }
     turnCount++;
     let response;
     try {
-      response = await callbacks.callAPI(currentMessages, providerTools);
+      if (yieldChunk !== void 0 && callbacks.callAPIStreaming !== void 0) {
+        const onTextDelta = (text) => {
+          yieldChunk({ type: "text_delta", text });
+        };
+        response = await callbacks.callAPIStreaming(currentMessages, providerTools, onTextDelta, signal);
+      } else {
+        response = await callbacks.callAPI(currentMessages, providerTools, signal);
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       throw new RuntimeError4("RILL-R004", `Provider API error: ${message}`, void 0, { cause: error });
@@ -415,6 +427,13 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
     for (const toolCall of toolCalls) {
       const { id, name, input } = toolCall;
       emitEvent("tool_call", { tool_name: name, args: input });
+      if (yieldChunk !== void 0) {
+        yieldChunk({
+          type: "tool_call",
+          name,
+          args: input
+        });
+      }
       const toolStartTime = Date.now();
       try {
         const result = await executeToolCall(name, input, tools, context);
@@ -422,6 +441,9 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
         toolResults.push({ id, name, result });
         executedToolCalls.push({ name, result });
         consecutiveErrors = 0;
+        if (yieldChunk !== void 0) {
+          yieldChunk({ type: "tool_result", name, result });
+        }
         emitEvent("tool_result", { tool_name: name, duration });
       } catch (error) {
         const duration = Date.now() - toolStartTime;
@@ -474,6 +496,9 @@ async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent,
     turns: turnCount
   };
 }
+function buildResponseMessages(inputMessages, assistantContent) {
+  return [...inputMessages, { role: "assistant", content: assistantContent }];
+}
 
 // ../../shared/ext-param/dist/param.js
 import { RuntimeError as RuntimeError5 } from "@rcrsr/rill";
@@ -503,7 +528,7 @@ var p = {
     validateParamName(name);
     return {
       name,
-      type: { type: "string" },
+      type: { kind: "string" },
       defaultValue: void 0,
       annotations: buildAnnotations(desc)
     };
@@ -520,7 +545,7 @@ var p = {
     validateParamName(name);
     return {
       name,
-      type: { type: "number" },
+      type: { kind: "number" },
       defaultValue: def,
       annotations: buildAnnotations(desc)
     };
@@ -537,7 +562,7 @@ var p = {
     validateParamName(name);
     return {
       name,
-      type: { type: "bool" },
+      type: { kind: "bool" },
       defaultValue: def,
       annotations: buildAnnotations(desc)
     };
@@ -553,7 +578,7 @@ var p = {
    */
   dict(name, desc, def, fields) {
     validateParamName(name);
-    const type = fields !== void 0 ? { type: "dict", fields } : { type: "dict" };
+    const type = fields !== void 0 ? { kind: "dict", fields } : { kind: "dict" };
     return {
       name,
       type,
@@ -571,7 +596,7 @@ var p = {
    */
   list(name, itemType, desc) {
     validateParamName(name);
-    const type = itemType !== void 0 ? { type: "list", element: itemType } : { type: "list" };
+    const type = itemType !== void 0 ? { kind: "list", element: itemType } : { kind: "list" };
     return {
       name,
       type,
@@ -590,7 +615,7 @@ var p = {
     validateParamName(name);
     return {
       name,
-      type: { type: "closure" },
+      type: { kind: "closure" },
       defaultValue: void 0,
       annotations: buildAnnotations(desc)
     };
@@ -673,235 +698,312 @@ function createGeminiExtension(config) {
       console.warn(`Failed to cleanup Gemini SDK: ${message}`);
     }
   };
-  const result = {
+  const fnDict = {
     // IR-4: gemini::message
     message: {
       params: [
         p.str("text"),
         p.dict("options", void 0, {}, {
-          system: { type: { type: "string" }, defaultValue: "" },
-          max_tokens: { type: { type: "number" }, defaultValue: 0 }
+          system: { type: { kind: "string" }, defaultValue: "" },
+          max_tokens: { type: { kind: "number" }, defaultValue: 0 }
         })
       ],
       fn: async (args, ctx) => {
-        const startTime = Date.now();
-        try {
-          const text = args["text"];
-          const options = args["options"] ?? {};
-          if (text.trim().length === 0) {
-            throw new RuntimeError6("RILL-R004", "prompt text cannot be empty");
+        const text = args["text"];
+        const options = args["options"] ?? {};
+        if (text.trim().length === 0) {
+          throw new RuntimeError6("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"] > 0 ? options["max_tokens"] : factoryMaxTokens;
+        const contents = [
+          {
+            role: "user",
+            parts: [{ text }]
           }
-          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
-          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
-          const contents = [
-            {
-              role: "user",
-              parts: [{ text }]
+        ];
+        const apiConfig = {};
+        if (system !== void 0) {
+          apiConfig.systemInstruction = system;
+        }
+        if (maxTokens !== void 0) {
+          apiConfig.maxOutputTokens = maxTokens;
+        }
+        if (factoryTemperature !== void 0) {
+          apiConfig.temperature = factoryTemperature;
+        }
+        const collectedChunks = [];
+        let streamError;
+        const streamAbortController = new AbortController();
+        const messageStartTime = Date.now();
+        async function* streamChunks() {
+          try {
+            const stream = await client.models.generateContentStream({
+              model: factoryModel,
+              contents,
+              config: { ...apiConfig, abortSignal: streamAbortController.signal }
+            });
+            for await (const chunk of stream) {
+              const delta = chunk.text ?? "";
+              if (delta) {
+                collectedChunks.push(delta);
+                yield delta;
+              }
             }
-          ];
-          const apiConfig = {};
-          if (system !== void 0) {
-            apiConfig.systemInstruction = system;
-          }
-          if (maxTokens !== void 0) {
-            apiConfig.maxOutputTokens = maxTokens;
+          } catch (error) {
+            streamError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+            const duration = Date.now() - messageStartTime;
+            emitExtensionEvent(ctx, {
+              event: "gemini:error",
+              subsystem: "extension:gemini",
+              error: streamError.message,
+              duration
+            });
+            throw streamError;
           }
-          if (factoryTemperature !== void 0) {
-            apiConfig.temperature = factoryTemperature;
+        }
+        const resolve = async () => {
+          if (streamError) {
+            throw streamError;
           }
-          const response = await client.models.generateContent({
-            model: factoryModel,
-            contents,
-            config: apiConfig
-          });
-          const content = response.text ?? "";
-          const result2 = {
+          const duration = Date.now() - messageStartTime;
+          const content = collectedChunks.join("");
+          const result = {
             content,
             model: factoryModel,
             usage: {
               input: 0,
-              // Gemini API doesn't always provide token counts
               output: 0
             },
             stop_reason: "stop",
             id: "",
-            // Gemini API doesn't provide request IDs in the same way
-            messages: [
-              ...system ? [{ role: "system", content: system }] : [],
-              { role: "user", content: text },
-              { role: "assistant", content }
-            ]
+            messages: buildResponseMessages(
+              [
+                ...system ? [{ role: "system", content: system }] : [],
+                { role: "user", content: text }
+              ],
+              content
+            )
           };
-          const duration = Date.now() - startTime;
           emitExtensionEvent(ctx, {
             event: "gemini:message",
             subsystem: "extension:gemini",
             duration,
             model: factoryModel,
-            usage: result2.usage,
+            usage: result.usage,
             request: contents,
             content
           });
-          return result2;
-        } catch (error) {
-          const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
-          emitExtensionEvent(ctx, {
-            event: "gemini:error",
-            subsystem: "extension:gemini",
-            error: rillError.message,
-            duration
-          });
-          throw rillError;
-        }
+          return result;
+        };
+        const retTypeStructure = {
+          kind: "dict",
+          fields: {
+            content: { type: { kind: "string" } },
+            model: { type: { kind: "string" } },
+            usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+            stop_reason: { type: { kind: "string" } },
+            id: { type: { kind: "string" } },
+            messages: { type: { kind: "list", element: { kind: "dict" } } }
+          }
+        };
+        return createRillStream({
+          chunks: streamChunks(),
+          resolve,
+          dispose: () => {
+            streamAbortController.abort();
+          },
+          chunkType: { kind: "string" },
+          retType: retTypeStructure
+        });
       },
       annotations: { description: "Send single message to Gemini API" },
-      returnType: rillTypeToTypeValue({
-        type: "dict",
-        fields: {
-          content: { type: { type: "string" } },
-          model: { type: { type: "string" } },
-          usage: { type: { type: "dict", fields: { input: { type: { type: "number" } }, output: { type: { type: "number" } } } } },
-          stop_reason: { type: { type: "string" } },
-          id: { type: { type: "string" } },
-          messages: { type: { type: "list", element: { type: "dict" } } }
+      returnType: structureToTypeValue({
+        kind: "stream",
+        chunk: { kind: "string" },
+        ret: {
+          kind: "dict",
+          fields: {
+            content: { type: { kind: "string" } },
+            model: { type: { kind: "string" } },
+            usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+            stop_reason: { type: { kind: "string" } },
+            id: { type: { kind: "string" } },
+            messages: { type: { kind: "list", element: { kind: "dict" } } }
+          }
         }
       })
     },
     // IR-5: gemini::messages
     messages: {
       params: [
-        p.list("messages", { type: "dict", fields: { role: { type: { type: "string" } }, content: { type: { type: "string" } } } }),
+        p.list("messages", { kind: "dict", fields: { role: { type: { kind: "string" } }, content: { type: { kind: "string" } } } }),
         p.dict("options", void 0, {}, {
-          system: { type: { type: "string" }, defaultValue: "" },
-          max_tokens: { type: { type: "number" }, defaultValue: 0 }
+          system: { type: { kind: "string" }, defaultValue: "" },
+          max_tokens: { type: { kind: "number" }, defaultValue: 0 }
         })
       ],
       fn: async (args, ctx) => {
-        const startTime = Date.now();
-        try {
-          const messages = args["messages"];
-          const options = args["options"] ?? {};
-          if (messages.length === 0) {
+        const inputMessages = args["messages"];
+        const options = args["options"] ?? {};
+        if (inputMessages.length === 0) {
+          throw new RuntimeError6(
+            "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"] > 0 ? options["max_tokens"] : factoryMaxTokens;
+        const contents = [];
+        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",
-              "messages list cannot be empty"
+              "message missing required 'role' field"
             );
           }
-          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
-          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
-          const contents = [];
-          for (let i = 0; i < messages.length; i++) {
-            const msg = messages[i];
-            if (!msg || typeof msg !== "object" || !("role" in msg)) {
+          const role = msg["role"];
+          if (role !== "user" && role !== "assistant" && role !== "tool") {
+            throw new RuntimeError6("RILL-R004", `invalid role '${role}'`);
+          }
+          if (role === "user" || role === "tool") {
+            if (!("content" in msg) || typeof msg["content"] !== "string") {
               throw new RuntimeError6(
                 "RILL-R004",
-                "message missing required 'role' field"
+                `${role} message requires 'content'`
               );
             }
-            const role = msg["role"];
-            if (role !== "user" && role !== "assistant" && role !== "tool") {
-              throw new RuntimeError6("RILL-R004", `invalid role '${role}'`);
+            contents.push({
+              role: "user",
+              parts: [{ text: 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 RuntimeError6(
+                "RILL-R004",
+                "assistant message requires 'content' or 'tool_calls'"
+              );
             }
-            if (role === "user" || role === "tool") {
-              if (!("content" in msg) || typeof msg["content"] !== "string") {
-                throw new RuntimeError6(
-                  "RILL-R004",
-                  `${role} message requires 'content'`
-                );
-              }
+            if (hasContent) {
               contents.push({
-                role: "user",
+                role: "model",
                 parts: [{ text: 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 RuntimeError6(
-                  "RILL-R004",
-                  "assistant message requires 'content' or 'tool_calls'"
-                );
-              }
-              if (hasContent) {
-                contents.push({
-                  role: "model",
-                  parts: [{ text: msg["content"] }]
-                });
-              }
             }
           }
-          const apiConfig = {};
-          if (system !== void 0) {
-            apiConfig.systemInstruction = system;
-          }
-          if (maxTokens !== void 0) {
-            apiConfig.maxOutputTokens = maxTokens;
+        }
+        const apiConfig = {};
+        if (system !== void 0) {
+          apiConfig.systemInstruction = system;
+        }
+        if (maxTokens !== void 0) {
+          apiConfig.maxOutputTokens = maxTokens;
+        }
+        if (factoryTemperature !== void 0) {
+          apiConfig.temperature = factoryTemperature;
+        }
+        const collectedChunks = [];
+        let streamError;
+        const streamAbortController = new AbortController();
+        const messagesStartTime = Date.now();
+        async function* streamChunks() {
+          try {
+            const stream = await client.models.generateContentStream({
+              model: factoryModel,
+              contents,
+              config: { ...apiConfig, abortSignal: streamAbortController.signal }
+            });
+            for await (const chunk of stream) {
+              const delta = chunk.text ?? "";
+              if (delta) {
+                collectedChunks.push(delta);
+                yield delta;
+              }
+            }
+          } catch (error) {
+            streamError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+            const duration = Date.now() - messagesStartTime;
+            emitExtensionEvent(ctx, {
+              event: "gemini:error",
+              subsystem: "extension:gemini",
+              error: streamError.message,
+              duration
+            });
+            throw streamError;
           }
-          if (factoryTemperature !== void 0) {
-            apiConfig.temperature = factoryTemperature;
+        }
+        const resolve = async () => {
+          if (streamError) {
+            throw streamError;
           }
-          const response = await client.models.generateContent({
-            model: factoryModel,
-            contents,
-            config: apiConfig
-          });
-          const content = response.text ?? "";
-          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 = {
+          const duration = Date.now() - messagesStartTime;
+          const content = collectedChunks.join("");
+          const result = {
             content,
             model: factoryModel,
             usage: {
               input: 0,
-              // Gemini API doesn't always provide token counts
               output: 0
             },
             stop_reason: "stop",
             id: "",
-            // Gemini API doesn't provide request IDs in the same way
-            messages: fullMessages
+            messages: buildResponseMessages(
+              inputMessages.map((m) => ({
+                role: m["role"],
+                content: m["content"] ?? ""
+              })),
+              content
+            )
           };
-          const duration = Date.now() - startTime;
           emitExtensionEvent(ctx, {
             event: "gemini:messages",
             subsystem: "extension:gemini",
             duration,
             model: factoryModel,
-            usage: result2.usage,
+            usage: result.usage,
             request: contents,
             content
           });
-          return result2;
-        } catch (error) {
-          const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
-          emitExtensionEvent(ctx, {
-            event: "gemini:error",
-            subsystem: "extension:gemini",
-            error: rillError.message,
-            duration
-          });
-          throw rillError;
-        }
+          return result;
+        };
+        const retTypeStructure = {
+          kind: "dict",
+          fields: {
+            content: { type: { kind: "string" } },
+            model: { type: { kind: "string" } },
+            usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+            stop_reason: { type: { kind: "string" } },
+            id: { type: { kind: "string" } },
+            messages: { type: { kind: "list", element: { kind: "dict" } } }
+          }
+        };
+        return createRillStream({
+          chunks: streamChunks(),
+          resolve,
+          dispose: () => {
+            streamAbortController.abort();
+          },
+          chunkType: { kind: "string" },
+          retType: retTypeStructure
+        });
       },
       annotations: { description: "Send multi-turn conversation to Gemini API" },
-      returnType: rillTypeToTypeValue({
-        type: "dict",
-        fields: {
-          content: { type: { type: "string" } },
-          model: { type: { type: "string" } },
-          usage: { type: { type: "dict", fields: { input: { type: { type: "number" } }, output: { type: { type: "number" } } } } },
-          stop_reason: { type: { type: "string" } },
-          id: { type: { type: "string" } },
-          messages: { type: { type: "list", element: { type: "dict" } } }
+      returnType: structureToTypeValue({
+        kind: "stream",
+        chunk: { kind: "string" },
+        ret: {
+          kind: "dict",
+          fields: {
+            content: { type: { kind: "string" } },
+            model: { type: { kind: "string" } },
+            usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+            stop_reason: { type: { kind: "string" } },
+            id: { type: { kind: "string" } },
+            messages: { type: { kind: "list", element: { kind: "dict" } } }
+          }
         }
       })
     },
@@ -949,7 +1051,7 @@ function createGeminiExtension(config) {
         }
       },
       annotations: { description: "Generate embedding vector for text" },
-      returnType: rillTypeToTypeValue({ type: "vector" })
+      returnType: structureToTypeValue({ kind: "vector" })
     },
     // IR-7: gemini::embed_batch
     embed_batch: {
@@ -1010,227 +1112,347 @@ function createGeminiExtension(config) {
         }
       },
       annotations: { description: "Generate embedding vectors for multiple texts" },
-      returnType: rillTypeToTypeValue({ type: "list", element: { type: "vector" } })
+      returnType: structureToTypeValue({ kind: "list", element: { kind: "vector" } })
     },
     // IR-8: gemini::tool_loop
     tool_loop: {
       params: [
         p.str("prompt"),
-        p.dict("options", void 0, {}, {
-          tools: { type: { type: "dict" } },
-          system: { type: { type: "string" }, defaultValue: "" },
-          max_tokens: { type: { type: "number" }, defaultValue: 0 },
-          max_errors: { type: { type: "number" }, defaultValue: 3 },
-          max_turns: { type: { type: "number" }, defaultValue: 10 },
-          messages: { type: { type: "list", element: { type: "dict", fields: { role: { type: { type: "string" } }, content: { type: { type: "string" } } } } }, defaultValue: [] }
+        {
+          name: "tools",
+          type: { kind: "dict", valueType: { kind: "closure" } },
+          defaultValue: void 0,
+          annotations: {}
+        },
+        p.dict("options", void 0, void 0, {
+          system: { type: { kind: "string" }, defaultValue: "" },
+          max_tokens: { type: { kind: "number" }, defaultValue: 0 },
+          max_errors: { type: { kind: "number" }, defaultValue: 3 },
+          max_turns: { type: { kind: "number" }, defaultValue: 10 },
+          messages: { type: { kind: "list", element: { kind: "dict", fields: { role: { type: { kind: "string" } }, content: { type: { kind: "string" } } } } }, defaultValue: [] }
         })
       ],
-      fn: async (args, ctx) => {
-        const startTime = Date.now();
-        try {
-          const prompt = args["prompt"];
-          const options = args["options"] ?? {};
-          if (prompt.trim().length === 0) {
-            throw new RuntimeError6("RILL-R004", "prompt text cannot be empty");
+      fn: (args, ctx) => {
+        const prompt = args["prompt"];
+        const toolsDict = args["tools"];
+        const options = args["options"] ?? {};
+        if (prompt.trim().length === 0) {
+          throw new RuntimeError6("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"] > 0 ? options["max_tokens"] : factoryMaxTokens;
+        const maxTurns = typeof options["max_turns"] === "number" ? options["max_turns"] : 10;
+        const maxErrors = typeof options["max_errors"] === "number" ? options["max_errors"] : 3;
+        const initialMessages = Array.isArray(options["messages"]) && options["messages"].length > 0 ? options["messages"] : [];
+        const contents = [];
+        for (const msg of initialMessages) {
+          if (typeof msg === "object" && msg !== null && "role" in msg && "content" in msg) {
+            const role = msg["role"];
+            if (role === "user") {
+              contents.push({
+                role: "user",
+                parts: [{ text: msg["content"] }]
+              });
+            } else if (role === "assistant") {
+              contents.push({
+                role: "model",
+                parts: [{ text: msg["content"] }]
+              });
+            }
           }
-          if (!("tools" in options) || !isDict2(options["tools"])) {
-            throw new RuntimeError6(
-              "RILL-R004",
-              "tool_loop requires 'tools' option"
-            );
+        }
+        contents.push({
+          role: "user",
+          parts: [{ text: prompt }]
+        });
+        const apiConfig = {
+          ...system !== void 0 && { systemInstruction: system },
+          ...maxTokens !== void 0 && { maxOutputTokens: maxTokens },
+          ...factoryTemperature !== void 0 && {
+            temperature: factoryTemperature
           }
-          const toolsDict = options["tools"];
-          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
-          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
-          const maxTurns = typeof options["max_turns"] === "number" ? options["max_turns"] : 10;
-          const maxErrors = typeof options["max_errors"] === "number" ? options["max_errors"] : 3;
-          const initialMessages = Array.isArray(options["messages"]) && options["messages"].length > 0 ? options["messages"] : [];
-          const contents = [];
-          for (const msg of initialMessages) {
-            if (typeof msg === "object" && msg !== null && "role" in msg && "content" in msg) {
-              const role = msg["role"];
-              if (role === "user") {
-                contents.push({
-                  role: "user",
-                  parts: [{ text: msg["content"] }]
-                });
-              } else if (role === "assistant") {
-                contents.push({
-                  role: "model",
-                  parts: [{ text: msg["content"] }]
-                });
-              }
+        };
+        const buildToolDeclarations = (toolDefs) => {
+          return toolDefs.map((def) => {
+            const properties = {};
+            for (const [propName, propDef] of Object.entries(
+              def.input_schema.properties
+            )) {
+              const prop = propDef;
+              const propType = prop["type"];
+              let schemaType = Type.STRING;
+              if (propType === "number") schemaType = Type.NUMBER;
+              if (propType === "boolean") schemaType = Type.BOOLEAN;
+              if (propType === "integer") schemaType = Type.INTEGER;
+              if (propType === "array") schemaType = Type.ARRAY;
+              if (propType === "object") schemaType = Type.OBJECT;
+              properties[propName] = {
+                type: schemaType,
+                description: prop["description"] ?? ""
+              };
             }
-          }
-          contents.push({
-            role: "user",
-            parts: [{ text: prompt }]
+            return {
+              name: def.name,
+              description: def.description,
+              parameters: {
+                type: Type.OBJECT,
+                properties,
+                required: def.input_schema.required
+              }
+            };
           });
-          const callbacks = {
-            // Build Gemini FunctionDeclaration format from tool definitions
-            buildTools: (toolDefs) => {
-              return toolDefs.map((def) => {
-                const properties = {};
-                for (const [propName, propDef] of Object.entries(
-                  def.input_schema.properties
-                )) {
-                  const prop = propDef;
-                  const propType = prop["type"];
-                  let schemaType = Type.STRING;
-                  if (propType === "number") schemaType = Type.NUMBER;
-                  if (propType === "boolean") schemaType = Type.BOOLEAN;
-                  if (propType === "integer") schemaType = Type.INTEGER;
-                  if (propType === "array") schemaType = Type.ARRAY;
-                  if (propType === "object") schemaType = Type.OBJECT;
-                  properties[propName] = {
-                    type: schemaType,
-                    description: prop["description"] ?? ""
-                  };
-                }
-                return {
-                  name: def.name,
-                  description: def.description,
-                  parameters: {
-                    type: Type.OBJECT,
-                    properties,
-                    required: def.input_schema.required
-                  }
-                };
-              });
-            },
-            // Call Gemini API
-            callAPI: async (msgs, tools) => {
-              const apiConfig = {
-                ...system !== void 0 && { systemInstruction: system },
-                ...maxTokens !== void 0 && { maxOutputTokens: maxTokens },
-                ...factoryTemperature !== void 0 && {
-                  temperature: factoryTemperature
-                },
+        };
+        let resolveNext;
+        const chunkQueue = [];
+        let streamDone = false;
+        let streamError;
+        let loopResultHolder;
+        const accumulatedTextDeltas = [];
+        const callbacks = {
+          buildTools: buildToolDeclarations,
+          callAPI: async (msgs, tools, signal) => {
+            return await client.models.generateContent({
+              model: factoryModel,
+              contents: msgs,
+              config: {
+                ...apiConfig,
+                ...signal !== void 0 && { abortSignal: signal },
                 tools: [
                   { functionDeclarations: tools }
                 ]
-              };
-              return await client.models.generateContent({
-                model: factoryModel,
-                contents: msgs,
-                config: apiConfig
-              });
-            },
-            // Extract tool calls from Gemini response
-            extractToolCalls: (response2) => {
-              if (!response2 || typeof response2 !== "object" || !("functionCalls" in response2)) {
-                return null;
               }
-              const functionCalls = response2.functionCalls;
-              if (!functionCalls || functionCalls.length === 0) {
-                return null;
-              }
-              return functionCalls.map((fc) => {
-                const call = fc;
-                return {
-                  id: call.id ?? "",
-                  name: call.name ?? "",
-                  input: call.args ?? {}
-                };
-              });
-            },
-            // Extract the model's content from Gemini response for conversation history
-            formatAssistantMessage: (response2) => {
-              if (!response2 || typeof response2 !== "object" || !("candidates" in response2)) {
-                return null;
-              }
-              const candidates = response2.candidates;
-              if (!Array.isArray(candidates) || candidates.length === 0) {
-                return null;
+            });
+          },
+          // IR-3: Streaming API path
+          callAPIStreaming: async (msgs, tools, onTextDelta, signal) => {
+            const stream = await client.models.generateContentStream({
+              model: factoryModel,
+              contents: msgs,
+              config: {
+                ...apiConfig,
+                ...signal !== void 0 && { abortSignal: signal },
+                tools: [
+                  { functionDeclarations: tools }
+                ]
               }
-              const candidate = candidates[0];
-              if (!candidate || typeof candidate !== "object" || !("content" in candidate)) {
-                return null;
+            });
+            let lastChunk;
+            for await (const chunk of stream) {
+              lastChunk = chunk;
+              const delta = chunk.text ?? "";
+              if (delta) {
+                onTextDelta(delta);
               }
-              return candidate.content;
-            },
-            // Format tool results into Gemini message format
-            formatToolResult: (toolResults) => {
-              const functionResponseParts = toolResults.map((tr) => ({
-                functionResponse: {
-                  name: tr.name,
-                  response: {
-                    result: tr.error ? `Error: ${tr.error}` : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
-                  }
-                }
-              }));
+            }
+            return lastChunk;
+          },
+          extractToolCalls: (response) => {
+            if (!response || typeof response !== "object" || !("functionCalls" in response)) {
+              return null;
+            }
+            const functionCalls = response.functionCalls;
+            if (!functionCalls || functionCalls.length === 0) {
+              return null;
+            }
+            return functionCalls.map((fc) => {
+              const call = fc;
               return {
-                role: "user",
-                parts: functionResponseParts
+                id: call.id ?? "",
+                name: call.name ?? "",
+                input: call.args ?? {}
               };
+            });
+          },
+          formatAssistantMessage: (response) => {
+            if (!response || typeof response !== "object" || !("candidates" in response)) {
+              return null;
             }
-          };
-          const loopResult = await executeToolLoop(
-            contents,
-            toolsDict,
-            maxErrors,
-            callbacks,
-            (event, data) => {
-              const eventMap = {
-                tool_call: "gemini:tool_call",
-                tool_result: "gemini:tool_result"
-              };
+            const candidates = response.candidates;
+            if (!Array.isArray(candidates) || candidates.length === 0) {
+              return null;
+            }
+            const candidate = candidates[0];
+            if (!candidate || typeof candidate !== "object" || !("content" in candidate)) {
+              return null;
+            }
+            return candidate.content;
+          },
+          formatToolResult: (toolResults) => {
+            const functionResponseParts = toolResults.map((tr) => ({
+              functionResponse: {
+                name: tr.name,
+                response: {
+                  result: tr.error ? `Error: ${tr.error}` : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
+                }
+              }
+            }));
+            return {
+              role: "user",
+              parts: functionResponseParts
+            };
+          }
+        };
+        const toolLoopAbortController = new AbortController();
+        const loopPromise = executeToolLoop(
+          contents,
+          toolsDict,
+          maxErrors,
+          callbacks,
+          (event, data) => {
+            const eventMap = {
+              tool_call: "gemini:tool_call",
+              tool_result: "gemini:tool_result"
+            };
+            emitExtensionEvent(ctx, {
+              event: eventMap[event] || event,
+              subsystem: "extension:gemini",
+              ...data
+            });
+          },
+          maxTurns,
+          ctx,
+          // yieldChunk — called from executeToolLoop for each text_delta, tool_call,
+          // or tool_result. Buffers the chunk and signals the generator to wake.
+          // AC-16: Also accumulate text_delta text for partial resolve on disconnect.
+          (chunk) => {
+            const chunkRecord = chunk;
+            if (chunkRecord["type"] === "text_delta" && typeof chunkRecord["text"] === "string") {
+              accumulatedTextDeltas.push(chunkRecord["text"]);
+            }
+            chunkQueue.push(chunk);
+            if (resolveNext) {
+              const r = resolveNext;
+              resolveNext = void 0;
+              r();
+            }
+          },
+          toolLoopAbortController.signal
+        ).then((result) => {
+          loopResultHolder = result;
+          streamDone = true;
+          if (resolveNext) {
+            const r = resolveNext;
+            resolveNext = void 0;
+            r();
+          }
+        }).catch((error) => {
+          streamError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          streamDone = true;
+          if (resolveNext) {
+            const r = resolveNext;
+            resolveNext = void 0;
+            r();
+          }
+        });
+        async function* streamGenerator() {
+          while (true) {
+            while (chunkQueue.length > 0) {
+              yield chunkQueue.shift();
+            }
+            if (streamDone) {
+              if (streamError) throw streamError;
+              break;
+            }
+            await new Promise((resolve2) => {
+              resolveNext = resolve2;
+            });
+          }
+        }
+        const inputMessages = [
+          ...initialMessages.map((m) => ({
+            role: m["role"],
+            content: m["content"] ?? ""
+          })),
+          { role: "user", content: prompt }
+        ];
+        const retTypeStructure = {
+          kind: "dict",
+          fields: {
+            content: { type: { kind: "string" } },
+            model: { type: { kind: "string" } },
+            usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+            stop_reason: { type: { kind: "string" } },
+            turns: { type: { kind: "number" } },
+            messages: { type: { kind: "list", element: { kind: "dict" } } }
+          }
+        };
+        const resolve = async () => {
+          const startTime = Date.now();
+          await loopPromise;
+          if (streamError) {
+            if (accumulatedTextDeltas.length > 0) {
+              const partialContent = accumulatedTextDeltas.join("");
               emitExtensionEvent(ctx, {
-                event: eventMap[event] || event,
+                event: "gemini:error",
                 subsystem: "extension:gemini",
-                ...data
+                error: streamError.message,
+                duration: Date.now()
               });
-            },
-            maxTurns,
-            ctx
-          );
-          const response = loopResult.response;
+              return {
+                content: partialContent,
+                model: factoryModel,
+                usage: { input: 0, output: 0 },
+                stop_reason: "error",
+                turns: 0,
+                messages: buildResponseMessages(inputMessages, partialContent)
+              };
+            }
+            const duration = Date.now();
+            emitExtensionEvent(ctx, {
+              event: "gemini:error",
+              subsystem: "extension:gemini",
+              error: streamError.message,
+              duration
+            });
+            throw streamError;
+          }
+          const result = loopResultHolder;
+          const response = result.response;
           const content = response && typeof response === "object" && "text" in response ? response.text ?? "" : "";
-          const result2 = {
+          const resolvedResult = {
             content,
             model: factoryModel,
-            usage: loopResult.totalTokens,
+            usage: result.totalTokens,
             stop_reason: response ? "stop" : "max_turns",
-            turns: loopResult.turns,
-            messages: [
-              ...initialMessages,
-              { role: "user", content: prompt },
-              { role: "assistant", content }
-            ]
+            turns: result.turns,
+            messages: response ? buildResponseMessages(inputMessages, content) : inputMessages
           };
-          const duration = Date.now() - startTime;
+          const total_duration = Date.now() - startTime;
           emitExtensionEvent(ctx, {
             event: "gemini:tool_loop",
             subsystem: "extension:gemini",
-            turns: result2.turns,
-            total_duration: duration,
-            usage: result2.usage,
+            turns: resolvedResult.turns,
+            total_duration,
+            usage: resolvedResult.usage,
             request: contents,
             content
           });
-          return result2;
-        } catch (error) {
-          const duration = Date.now() - startTime;
-          const rillError = error instanceof RuntimeError6 ? error : mapProviderError("Gemini", error, detectGeminiError);
-          emitExtensionEvent(ctx, {
-            event: "gemini:error",
-            subsystem: "extension:gemini",
-            error: rillError.message,
-            duration
-          });
-          throw rillError;
-        }
+          return resolvedResult;
+        };
+        return createRillStream({
+          chunks: streamGenerator(),
+          resolve,
+          dispose: () => {
+            toolLoopAbortController.abort();
+          },
+          chunkType: { kind: "dict" },
+          retType: retTypeStructure
+        });
       },
       annotations: { description: "Execute tool-use loop with Gemini API" },
-      returnType: rillTypeToTypeValue({
-        type: "dict",
-        fields: {
-          content: { type: { type: "string" } },
-          model: { type: { type: "string" } },
-          usage: { type: { type: "dict", fields: { input: { type: { type: "number" } }, output: { type: { type: "number" } } } } },
-          stop_reason: { type: { type: "string" } },
-          turns: { type: { type: "number" } },
-          messages: { type: { type: "list", element: { type: "dict" } } }
+      returnType: structureToTypeValue({
+        kind: "stream",
+        chunk: { kind: "dict" },
+        ret: {
+          kind: "dict",
+          fields: {
+            content: { type: { kind: "string" } },
+            model: { type: { kind: "string" } },
+            usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+            stop_reason: { type: { kind: "string" } },
+            turns: { type: { kind: "number" } },
+            messages: { type: { kind: "list", element: { kind: "dict" } } }
+          }
         }
       })
     },
@@ -1239,10 +1461,10 @@ function createGeminiExtension(config) {
       params: [
         p.str("prompt"),
         p.dict("options", void 0, {}, {
-          schema: { type: { type: "dict" } },
-          system: { type: { type: "string" }, defaultValue: "" },
-          max_tokens: { type: { type: "number" }, defaultValue: 0 },
-          messages: { type: { type: "list", element: { type: "dict", fields: { role: { type: { type: "string" } }, content: { type: { type: "string" } } } } }, defaultValue: [] }
+          schema: { type: { kind: "dict" } },
+          system: { type: { kind: "string" }, defaultValue: "" },
+          max_tokens: { type: { kind: "number" }, defaultValue: 0 },
+          messages: { type: { kind: "list", element: { kind: "dict", fields: { role: { type: { kind: "string" } }, content: { type: { kind: "string" } } } } }, defaultValue: [] }
         })
       ],
       fn: async (args, ctx) => {
@@ -1268,7 +1490,7 @@ function createGeminiExtension(config) {
             required: jsonSchema.required
           };
           const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
-          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const maxTokens = typeof options["max_tokens"] === "number" && options["max_tokens"] > 0 ? options["max_tokens"] : factoryMaxTokens;
           const contents = [];
           if ("messages" in options && Array.isArray(options["messages"])) {
             const prependedMessages = options["messages"];
@@ -1361,21 +1583,28 @@ function createGeminiExtension(config) {
         }
       },
       annotations: { description: "Generate structured output from Gemini API" },
-      returnType: rillTypeToTypeValue({
-        type: "dict",
+      returnType: structureToTypeValue({
+        kind: "dict",
         fields: {
-          data: { type: { type: "any" } },
-          raw: { type: { type: "string" } },
-          model: { type: { type: "string" } },
-          usage: { type: { type: "dict", fields: { input: { type: { type: "number" } }, output: { type: { type: "number" } } } } },
-          stop_reason: { type: { type: "string" } },
-          id: { type: { type: "string" } }
+          data: { type: { kind: "any" } },
+          raw: { type: { kind: "string" } },
+          model: { type: { kind: "string" } },
+          usage: { type: { kind: "dict", fields: { input: { type: { kind: "number" } }, output: { type: { kind: "number" } } } } },
+          stop_reason: { type: { kind: "string" } },
+          id: { type: { kind: "string" } }
         }
       })
     }
   };
-  result.dispose = dispose;
-  return result;
+  const callableDict = {
+    message: toCallable(fnDict.message),
+    messages: toCallable(fnDict.messages),
+    embed: toCallable(fnDict.embed),
+    embed_batch: toCallable(fnDict.embed_batch),
+    tool_loop: toCallable(fnDict.tool_loop),
+    generate: toCallable(fnDict.generate)
+  };
+  return { value: callableDict, dispose };
 }
 
 // src/index.ts