@tyvm/knowhow 0.0.144 → 0.0.146

package/src/clients/gemini.ts

@@ -225,17 +225,44 @@ export class GenericGeminiClient implements GenericClient {
           msg.tool_calls &&
           msg.tool_calls.length > 0
         ) {
+          // Look up any captured thoughtSignatures for this assistant message so
+          // we can re-attach them to the matching functionCall part (required by
+          // Gemini 3 to preserve reasoning continuity across tool-use turns).
+          const details = (msg as any)._reasoning_details;
+          const sigByCallId: { [id: string]: string } = {};
+          const standaloneThoughtSigs: string[] = [];
+          if (details && details.provider === "gemini" && Array.isArray(details.items)) {
+            for (const item of details.items) {
+              if (item?.kind === "functionCall" && item.callId) {
+                sigByCallId[item.callId] = item.thoughtSignature;
+              } else if (item?.kind === "thoughtSignature" && item.thoughtSignature) {
+                standaloneThoughtSigs.push(item.thoughtSignature);
+              }
+            }
+          }
           for (const toolCall of msg.tool_calls) {
-            parts.push({
+            const callPart: any = {
               functionCall: {
                 name: toolCall.function.name,
                 // Google expects arguments as a parsed object, not a string
                 args: JSON.parse(toolCall.function.arguments || "{}"),
               },
-            });
+            };
+            if (sigByCallId[toolCall.id]) {
+              callPart.thoughtSignature = sigByCallId[toolCall.id];
+            }
+            parts.push(callPart);
             // Store the tool call to potentially link with a future tool response message
             assistantToolCalls[toolCall.id] = toolCall;
           }
+          // Re-attach any standalone thought-part signatures onto the leading
+          // text part(s) so reasoning-only thoughts are also round-tripped.
+          for (let s = 0; s < standaloneThoughtSigs.length; s++) {
+            const p: any = parts[s];
+            if (p && "text" in p && !p.thoughtSignature) {
+              p.thoughtSignature = standaloneThoughtSigs[s];
+            }
+          }
         }
 
         if (parts.length > 0) {
@@ -407,9 +434,13 @@ export class GenericGeminiClient implements GenericClient {
     // Gemini 3.x — use thinkingLevel
     if (GoogleThinkingLevelModels.includes(model)) {
       const levelMap: Record<string, string> = {
+        none: "minimal",
+        minimal: "minimal",
         low: "low",
         medium: "medium",
         high: "high",
+        xhigh: "high",
+        max: "high",
       };
       return {
         thinkingLevel: levelMap[effort] ?? "low",
@@ -420,9 +451,13 @@ export class GenericGeminiClient implements GenericClient {
     if (GoogleThinkingBudgetModels.includes(model)) {
       // Map effort to token budget
       const budgetMap: Record<string, number> = {
+        none: 0,
+        minimal: 512,
         low: 1024,
         medium: 8192,
         high: -1, // dynamic
+        xhigh: -1,
+        max: -1,
       };
       return {
         thinkingBudget: budgetMap[effort] ?? 1024,
@@ -499,24 +534,51 @@ export class GenericGeminiClient implements GenericClient {
             return { message };
           }
 
+          // Capture Gemini thoughtSignatures so they can be round-tripped on the
+          // next turn. Gemini 3 REQUIRES these to be echoed back on the matching
+          // functionCall part or it returns a 400 "Thought signature is not
+          // valid" on the 2nd+ tool-calling turn. We key them by tool-call id
+          // (and also keep any standalone thought-part signatures in order).
+          const reasoningItems: any[] = [];
+
           candidate?.content?.parts?.forEach((part) => {
             if ("text" in part && typeof part.text === "string") {
               textContent += part.text; // Concatenate text parts
+              if ((part as any).thoughtSignature) {
+                reasoningItems.push({
+                  kind: "thoughtSignature",
+                  thoughtSignature: (part as any).thoughtSignature,
+                });
+              }
             } else if ("functionCall" in part && part.functionCall) {
+              const callId =
+                part.functionCall.id ||
+                `fc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
               message.tool_calls.push({
-                id:
-                  part.functionCall.id ||
-                  `fc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                id: callId,
                 type: "function",
                 function: {
                   name: part.functionCall.name,
                   arguments: JSON.stringify(part.functionCall.args || {}),
                 },
               });
+              if ((part as any).thoughtSignature) {
+                reasoningItems.push({
+                  kind: "functionCall",
+                  callId,
+                  thoughtSignature: (part as any).thoughtSignature,
+                });
+              }
             }
           });
 
           message.content = textContent || null;
+          if (reasoningItems.length > 0) {
+            (message as any)._reasoning_details = {
+              provider: "gemini",
+              items: reasoningItems,
+            };
+          }
 
           return { message };
         }) || []; // Handle case with no candidates

package/src/clients/http.ts

@@ -92,6 +92,33 @@ export class HttpClient implements GenericClient {
     this.pricingMap = pricingMap;
   }
 
+  /**
+   * A stable provider id used to tag/read the provider-agnostic
+   * `_reasoning_details` slot. Reasoning items are opaque and only meaningful
+   * to the provider that produced them, so we key on the client's baseUrl.
+   */
+  protected reasoningProviderId(): string {
+    return `http:${this.baseUrl}`;
+  }
+
+  /**
+   * Resolve the provider-native reasoning items (Responses API `reasoning`
+   * items with encrypted_content) to re-inject for an assistant message,
+   * reading the provider-agnostic `_reasoning_details` slot only when it was
+   * produced by this same client.
+   */
+  protected getReasoningItems(msg: any): any[] {
+    const details = msg?._reasoning_details;
+    if (
+      details &&
+      details.provider === this.reasoningProviderId() &&
+      Array.isArray(details.items)
+    ) {
+      return details.items;
+    }
+    return [];
+  }
+
   /**
    * Returns the pricing entry for a specific model, or all pricing entries if no model is given.
    * Returns undefined for a specific model if no pricing is known.
@@ -299,22 +326,44 @@ export class HttpClient implements GenericClient {
         .trim() || undefined;
 
       // Convert messages to Responses API input format
+      // Responses API hard limit: 10,485,760 chars per function_call_output.output
+      const MAX_TOOL_OUTPUT = 10_485_000;
+      const truncateToolOutput = (s: string) =>
+        s.length > MAX_TOOL_OUTPUT
+          ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+          : s;
       const input: any[] = nonSystemMessages.map((msg) => {
         if (msg.role === "tool") {
           return {
             type: "function_call_output",
             call_id: msg.tool_call_id,
-            output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            output: truncateToolOutput(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)),
           };
         }
         if (msg.role === "assistant" && msg.tool_calls?.length) {
-          return (msg.tool_calls as any[]).map((tc: any) => ({
+          // Re-inject any captured reasoning items (encrypted_content) BEFORE
+          // the function_call items so the model preserves its chain-of-thought
+          // across tool-use turns instead of re-deriving it each turn.
+          const reasoningItems = this.getReasoningItems(msg);
+          return [
+            ...reasoningItems,
+            ...(msg.tool_calls as any[]).map((tc: any) => ({
             type: "function_call",
             id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
             call_id: tc.id,
             name: tc.function.name,
             arguments: tc.function.arguments,
-          }));
+            })),
+          ];
+        }
+        if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+          return [
+            ...this.getReasoningItems(msg),
+            {
+              role: msg.role,
+              content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+            },
+          ];
         }
         return {
           role: msg.role,
@@ -336,7 +385,18 @@ export class HttpClient implements GenericClient {
         ...(instructions && { instructions }),
         ...(options.max_tokens && { max_output_tokens: options.max_tokens }),
         ...(tools?.length && { tools, tool_choice: "auto" }),
-        store,
+        // Reasoning persistence: store server-side when requested, otherwise
+        // ask the provider to return encrypted reasoning content so we can
+        // thread the reasoning items back into the next request ourselves.
+        store: options.store === true ? true : store,
+        ...(options.previous_response_id && {
+          previous_response_id: options.previous_response_id,
+        }),
+        ...(options.store !== true &&
+          options.reasoning_effort &&
+          options.reasoning_effort !== "none" && {
+            include: ["reasoning.encrypted_content"],
+          }),
         ...this.extra_body,
       };
 
@@ -368,6 +428,10 @@ export class HttpClient implements GenericClient {
       // Collect text content and tool calls from output items
       let textContent: string | null = null;
       const toolCalls: any[] = [];
+      // Reasoning items (encrypted_content) to thread back into the next turn,
+      // plus a human-readable summary of the model's thinking (if present).
+      const reasoningItems: any[] = [];
+      let reasoningSummary: string | null = null;
 
       for (const item of data.output ?? []) {
         if (item.type === "message") {
@@ -376,6 +440,15 @@ export class HttpClient implements GenericClient {
               textContent = (textContent ?? "") + part.text;
             }
           }
+        } else if (item.type === "reasoning") {
+          reasoningItems.push(item);
+          const summaryParts = item.summary ?? [];
+          for (const part of summaryParts) {
+            const text = typeof part === "string" ? part : part?.text;
+            if (text) {
+              reasoningSummary = (reasoningSummary ?? "") + text;
+            }
+          }
         } else if (item.type === "function_call") {
           toolCalls.push({
             id: item.call_id,
@@ -392,12 +465,20 @@ export class HttpClient implements GenericClient {
               role: "assistant",
               content: textContent,
               ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+              ...(reasoningSummary && { reasoning_summary: reasoningSummary }),
+              ...(reasoningItems.length > 0 && {
+                _reasoning_details: {
+                  provider: this.reasoningProviderId(),
+                  items: reasoningItems,
+                },
+              }),
             },
           },
         ],
         model: data.model ?? options.model,
         usage,
         usd_cost: data.usd_cost ?? this.calculateCost(options.model, usage),
+        response_id: data.id,
       };
     });
   }

package/src/clients/index.ts

@@ -58,6 +58,7 @@ import { GitHubCopilotClient } from "./copilot";
 import { GenericLlamaClient } from "./llama";
 import { GenericFireworksClient } from "./fireworks";
 import { GenericMetaClient } from "./meta";
+import { GenericQwenClient } from "./qwen";
 export {
   OpenAiTextPricing,
   AnthropicTextPricing,
@@ -103,6 +104,7 @@ const BUILT_IN_PROVIDER_REGISTRY: Record<string, ProviderRegistryEntry> = {
   llama: { clientClass: GenericLlamaClient },
   fireworks: { clientClass: GenericFireworksClient },
   meta: { clientClass: GenericMetaClient },
+  qwen: { clientClass: GenericQwenClient },
   knowhow: {
     createClient: (entry: ModelProvider) => {
       const jwt = loadKnowhowJwt();
@@ -134,6 +136,7 @@ const DEFAULT_PROVIDERS: ModelProvider[] = [
   { provider: "llama", envKey: "LLAMA_API_KEY" },
   { provider: "fireworks", envKey: "FIREWORKS_API_KEY" },
   { provider: "meta", envKey: "META_API_KEY" },
+  { provider: "qwen", envKey: "QWEN_CLOUD_API_KEY" },
 ];
 
 export class AIClient {
@@ -1075,3 +1078,4 @@ export * from "./llama";
 export * from "./copilot";
 export * from "./fireworks";
 export * from "./meta";
+export * from "./qwen";

package/src/clients/openai.ts

@@ -22,13 +22,17 @@ import {
   FileUploadResponse,
   FileDownloadOptions,
   FileDownloadResponse,
+  Message,
 } from "./types";
 import {
   ChatCompletionMessageParam,
   ChatCompletionToolMessageParam,
   ChatCompletionMessageToolCall,
 } from "openai/resources/chat";
-import { ResponseFunctionToolCall } from "openai/resources/responses/responses";
+import {
+  ResponseFunctionToolCall,
+  ResponseInputMessageContentList,
+} from "openai/resources/responses/responses";
 
 import {
   EmbeddingModels,
@@ -108,9 +112,10 @@ export class GenericOpenAiClient implements GenericClient {
 
   resolveReasoningEffort(options: CompletionOptions): "low" | "medium" | "high" {
     const effort = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
-    // "none" is not a valid SDK ReasoningEffort — callers that need "none" should
-    // check isReasoningDisabled() separately and skip the reasoning params.
-    if (effort === "none") return "low";
+    // Chat Completions only accepts low/medium/high. Preserve newer values on
+    // the Responses API, but map them to the nearest legacy level here.
+    if (effort === "none" || effort === "minimal") return "low";
+    if (effort === "xhigh" || effort === "max") return "high";
     return effort;
   }
 
@@ -121,7 +126,9 @@ export class GenericOpenAiClient implements GenericClient {
    */
   resolveReasoningEffortForModel(options: CompletionOptions): string {
     const raw = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
-    const requested = raw === "none" ? "none" : raw;
+    // Anthropic calls its highest level `max`; OpenAI calls it `xhigh`.
+    // Accept both provider-neutral CLI spellings.
+    const requested = raw === "max" ? "xhigh" : raw;
     const pricing = OpenAiTextPricing[options.model];
     const supportedLevels = pricing?.reasoningLevels;
     if (!supportedLevels || supportedLevels.length === 0) {
@@ -140,6 +147,75 @@ export class GenericOpenAiClient implements GenericClient {
     return options.reasoning_effort === "none";
   }
 
+  /**
+   * OpenAI only permits image parts on user messages. A Chat Completions
+   * `tool` message may contain text parts, but not `image_url` parts. Keep the
+   * required tool result and attach images in a following user message.
+   */
+  toChatCompletionMessages(
+    messages: CompletionOptions["messages"]
+  ): ChatCompletionMessageParam[] {
+    return messages.flatMap((msg): ChatCompletionMessageParam[] => {
+      if (msg.role !== "tool") return [msg as ChatCompletionMessageParam];
+
+      const parts = Array.isArray(msg.content) ? msg.content : [];
+      const unsupportedPart = parts.find(
+        (part) => part.type !== "text" && part.type !== "image_url"
+      );
+      if (unsupportedPart) {
+        throw new Error(
+          `OpenAI Chat Completions cannot attach ${unsupportedPart.type} content to a tool result.`
+        );
+      }
+      const imageParts = parts.filter((part) => part.type === "image_url");
+      const textParts = parts.filter((part) => part.type === "text");
+      const toolMessage: ChatCompletionToolMessageParam = {
+        role: "tool",
+        tool_call_id: msg.tool_call_id!,
+        content: Array.isArray(msg.content)
+          ? textParts.length
+            ? textParts
+            : [{
+                type: "text",
+                text: "Image output attached in the following user message.",
+              }]
+          : msg.content || "",
+      };
+
+      if (!imageParts.length) return [toolMessage];
+      return [
+        toolMessage,
+        { role: "user", content: imageParts } as ChatCompletionMessageParam,
+      ];
+    });
+  }
+
+  /** Convert the CLI's Chat Completions-style parts to Responses API parts. */
+  toResponseContent(
+    content: Message["content"]
+  ): string | ResponseInputMessageContentList {
+    if (!Array.isArray(content)) return content || "";
+    const result: ResponseInputMessageContentList = [];
+    for (const part of content) {
+      if (part.type === "text") {
+        result.push({ type: "input_text", text: part.text });
+      }
+      else if (part.type === "image_url") {
+        result.push({
+          type: "input_image",
+          image_url: part.image_url.url,
+          detail: part.image_url.detail || "auto",
+        });
+      }
+      else {
+        throw new Error(
+          `OpenAI Responses API conversion does not support ${part.type} content.`
+        );
+      }
+    }
+    return result;
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -148,17 +224,7 @@ export class GenericOpenAiClient implements GenericClient {
       return this.createChatResponse(options);
     }
 
-    const openaiMessages = options.messages.map((msg) => {
-      if (msg.role === "tool") {
-        return {
-          ...msg,
-          content: msg.content || "",
-          role: "tool",
-          tool_call_id: msg.tool_call_id,
-        } as ChatCompletionToolMessageParam;
-      }
-      return msg as ChatCompletionMessageParam;
-    });
+    const openaiMessages = this.toChatCompletionMessages(options.messages);
 
     const response = await this.client.chat.completions.create({
       model: options.model,
@@ -222,17 +288,7 @@ export class GenericOpenAiClient implements GenericClient {
       return;
     }
 
-    const openaiMessages = options.messages.map((msg) => {
-      if (msg.role === "tool") {
-        return {
-          ...msg,
-          content: msg.content || "",
-          role: "tool",
-          tool_call_id: msg.tool_call_id,
-        } as ChatCompletionToolMessageParam;
-      }
-      return msg as ChatCompletionMessageParam;
-    });
+    const openaiMessages = this.toChatCompletionMessages(options.messages);
 
     const stream = await this.client.chat.completions.create({
       model: options.model,
@@ -307,6 +363,20 @@ export class GenericOpenAiClient implements GenericClient {
     }
   }
 
+  /**
+   * Resolve the OpenAI-native reasoning items to re-inject for an assistant
+   * message. Reads the provider-agnostic `_reasoning_details` slot (only when
+   * it was produced by this provider) and falls back to the deprecated
+   * `_reasoning_items` for backward compatibility.
+   */
+  private getReasoningItems(msg: any): any[] {
+    const details = (msg as any)._reasoning_details;
+    if (details && details.provider === "openai" && Array.isArray(details.items)) {
+      return details.items;
+    }
+    return (msg as any)._reasoning_items ?? [];
+  }
+
   async createChatResponse(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -324,30 +394,68 @@ export class GenericOpenAiClient implements GenericClient {
 
     // Convert chat messages to Responses API input items
     // The Responses API accepts: user/assistant/system messages and function_call_output items
+    // OpenAI Responses API hard limit: 10,485,760 chars per function_call_output.output
+    const MAX_TOOL_OUTPUT = 10_485_000;
+    const truncateToolOutput = (s: string) =>
+      s.length > MAX_TOOL_OUTPUT
+        ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+        : s;
     const input: any[] = nonSystemMessages.map((msg) => {
       if (msg.role === "tool") {
-        // tool result → function_call_output
-        return {
+        // OpenAI function outputs cannot directly contain image content. Send
+        // the required function output, then attach images as a user message.
+        const parts = Array.isArray(msg.content) ? msg.content : [];
+        const imageParts = parts.filter((part) => part.type === "image_url");
+        const text = parts
+          .filter((part) => part.type === "text")
+          .map((part: any) => part.text)
+          .join("\n");
+        const toolOutput = {
           type: "function_call_output",
           call_id: msg.tool_call_id,
-          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          output: truncateToolOutput(typeof msg.content === "string"
+            ? msg.content
+            : text || "Image output attached in the following user message."),
         };
+        if (!imageParts.length) return toolOutput;
+        return [
+          toolOutput,
+          { role: "user", content: this.toResponseContent(imageParts) },
+        ];
       }
       if (msg.role === "assistant" && msg.tool_calls?.length) {
-        // assistant message with tool calls → function_call items
-        return msg.tool_calls.map((tc) => ({
+        // assistant message with tool calls → function_call items.
+        // If the prior turn captured reasoning items (encrypted_content path),
+        // re-inject them *before* the function_call items so the model keeps its
+        // chain-of-thought instead of re-deriving it from scratch.
+        const reasoningItems = this.getReasoningItems(msg);
+        return [
+          ...reasoningItems,
+          ...msg.tool_calls.map((tc) => ({
           type: "function_call",
           // id must start with 'fc_'; call_id is the original call_ ID used for function_call_output matching
           id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
           call_id: tc.id,
           name: tc.function.name,
           arguments: tc.function.arguments,
-        }));
+          })),
+        ];
+      }
+      if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+        // assistant message (no tool calls) that carried reasoning items →
+        // re-inject reasoning items, then the visible message content.
+        return [
+          ...this.getReasoningItems(msg),
+          {
+            role: msg.role,
+            content: this.toResponseContent(msg.content),
+          },
+        ];
       }
       // Regular user/assistant message
       return {
         role: msg.role,
-        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        content: this.toResponseContent(msg.content),
       };
     }).flat();
 
@@ -360,10 +468,29 @@ export class GenericOpenAiClient implements GenericClient {
       strict: false,
     }));
 
+    // Reasoning persistence:
+    //  - store === true  → OpenAI persists the response server-side; the next
+    //    turn passes previous_response_id to continue the reasoning chain.
+    //  - store !== true  → stateless; ask OpenAI to return encrypted reasoning
+    //    content so we can thread it back into the next request's input ourselves.
+    const store = options.store === true;
+    const wantsReasoning =
+      OpenAiReasoningModels.includes(options.model) &&
+      !this.isReasoningDisabled(options);
+
     const response = await this.client.responses.create({
       model: options.model as any,
       input,
       ...(instructions && { instructions }),
+      ...(store && { store: true }),
+      ...(!store && { store: false }),
+      ...(options.previous_response_id && {
+        previous_response_id: options.previous_response_id,
+      }),
+      // When stateless, request encrypted reasoning so we can re-inject it next turn.
+      ...(!store && wantsReasoning && {
+        include: ["reasoning.encrypted_content"],
+      }),
       // Don't limit max_output_tokens for Responses API - codex truncates tool call arguments when limited
       ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
         max_output_tokens: Math.max(options.max_tokens || 0, 16000),
@@ -376,7 +503,6 @@ export class GenericOpenAiClient implements GenericClient {
         tools,
         tool_choice: "auto",
       }),
-      store: false,
     } as any);
 
     // Map Responses API usage to Chat Completions usage format
@@ -405,6 +531,10 @@ export class GenericOpenAiClient implements GenericClient {
     // Collect text content and tool calls from the output items
     let textContent: string | null = null;
     const toolCalls: ChatCompletionMessageToolCall[] = [];
+    // Reasoning items (with encrypted_content) to thread back into the next turn,
+    // and a human-readable summary of the model's thinking (when requested).
+    const reasoningItems: any[] = [];
+    let reasoningSummary: string | null = null;
 
     for (const item of response.output) {
       if (item.type === "message") {
@@ -415,6 +545,18 @@ export class GenericOpenAiClient implements GenericClient {
             textContent = (textContent ?? "") + part.text;
           }
         }
+      } else if (item.type === "reasoning") {
+        // ResponseReasoningItem — keep the raw item so we can re-inject it
+        // (it carries encrypted_content when include was requested), and pull
+        // out any human-readable summary text.
+        reasoningItems.push(item);
+        const summaryParts = (item as any).summary ?? [];
+        for (const part of summaryParts) {
+          const text = typeof part === "string" ? part : part?.text;
+          if (text) {
+            reasoningSummary = (reasoningSummary ?? "") + text;
+          }
+        }
       } else if (item.type === "function_call") {
         // ResponseFunctionToolCall
         const fc = item as ResponseFunctionToolCall;
@@ -444,12 +586,21 @@ export class GenericOpenAiClient implements GenericClient {
             role: "assistant",
             content: textContent,
             ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+            ...(reasoningSummary && { reasoning_summary: reasoningSummary }),
+            // Stash the raw reasoning items (encrypted_content) so the next call
+            // to createChatResponse can re-inject them into the input. We populate
+            // both the provider-agnostic slot and the deprecated legacy field.
+            ...(reasoningItems.length > 0 && {
+              _reasoning_items: reasoningItems,
+              _reasoning_details: { provider: "openai", items: reasoningItems },
+            }),
           },
         },
       ],
       model: options.model,
       usage,
       usd_cost: usdCost,
+      response_id: (response as any).id,
     };
   }