arcane-os 0.3.4 → 0.3.6

package/browser-runtime/ai/model-controller.mjs

@@ -313,10 +313,10 @@ export function completeValueText(value) {
 
 function textFromCompletion(completion) {
   if (!Array.isArray(completion?.choices)) return completeValueText(completion);
-  return completion.choices.map((choice) => {
-    const content = choice?.message?.content;
-    return content === undefined ? completeValueText(choice) : completeValueText(content);
-  }).join("\n");
+  if(completion.choices.length>1)return completeValueText(completion);
+  const choice=completion.choices[0];
+  const content=choice?.message?.content;
+  return content===undefined?completeValueText(choice):completeValueText(content);
 }
 
 function structuralToolCall(call,location){
@@ -369,9 +369,11 @@ function structuralToolCall(call,location){
     );
   }
   return {
+    ...call,
     id:call.id,
     type:"function",
     function:{
+      ...call.function,
       name:call.function.name,
       arguments:call.function.arguments,
     },
@@ -464,15 +466,13 @@ function structuralRequest(value){
     throw new TypeError("AI request messages must be an array.");
   }
   requireToolMessageSchemas(value.tools,"AI request tools");
-  if(value.parallelToolCalls===true||value.parallel_tool_calls===true){
-    throw new ArcaneAIError(
-      "ARCANE_AI_PARALLEL_TOOLS_UNSUPPORTED",
-      "The Arcane chat session accepts one structural tool call at a time.",
-      {operation:"request"},
-    );
+  for(const key of ["parallelToolCalls","parallel_tool_calls"]){
+    if(Object.hasOwn(value,key)&&typeof value[key]!=="boolean"){
+      throw new TypeError(`AI request ${key} must be a boolean when provided.`);
+    }
   }
 
-  let pendingToolCallId=null;
+  const pendingToolCallIds=new Set();
   for(const [messageIndex,message] of (value.messages??[]).entries()){
     const calls=structuralCallsFromMessage(
       message,
@@ -487,18 +487,28 @@ function structuralRequest(value){
           {operation:"request"},
         );
       }
-      if(calls.length>1||pendingToolCallId!==null&&calls.length){
+      if(pendingToolCallIds.size&&calls.length){
         throw new ArcaneAIError(
-          "ARCANE_AI_PARALLEL_TOOLS_UNSUPPORTED",
-          "The Arcane chat session accepts one structural tool call at a time.",
+          "ARCANE_AI_TOOL_RESULT_REQUIRED",
+          "Every pending structural tool result must be supplied before another assistant tool-call sequence.",
           {operation:"request"},
         );
       }
       if(calls.length){
-        pendingToolCallId=structuralToolCall(
-          calls[0],
-          `AI request messages[${String(messageIndex)}].tool_calls[0]`,
-        ).id;
+        for(const [callIndex,call] of calls.entries()){
+          const normalized=structuralToolCall(
+            call,
+            `AI request messages[${String(messageIndex)}].tool_calls[${String(callIndex)}]`,
+          );
+          if(pendingToolCallIds.has(normalized.id)){
+            throw new ArcaneAIError(
+              "ARCANE_AI_TOOL_CALL_INVALID",
+              `AI request messages[${String(messageIndex)}].tool_calls contains a duplicate ID.`,
+              {operation:"request"},
+            );
+          }
+          pendingToolCallIds.add(normalized.id);
+        }
         openedToolCall=true;
       }
     }
@@ -514,9 +524,9 @@ function structuralRequest(value){
         );
       }
       if(
-        pendingToolCallId===null
+        !pendingToolCallIds.size
         ||typeof message.tool_call_id!=="string"
-        ||message.tool_call_id!==pendingToolCallId
+        ||!pendingToolCallIds.has(message.tool_call_id)
       ){
         throw new ArcaneAIError(
           "ARCANE_AI_INVALID_TOOL_MESSAGE",
@@ -524,8 +534,8 @@ function structuralRequest(value){
           {operation:"request"},
         );
       }
-      pendingToolCallId=null;
-    }else if(pendingToolCallId!==null&&!openedToolCall){
+      pendingToolCallIds.delete(message.tool_call_id);
+    }else if(pendingToolCallIds.size&&!openedToolCall){
       throw new ArcaneAIError(
         "ARCANE_AI_TOOL_RESULT_REQUIRED",
         `AI request messages[${String(messageIndex)}] precedes the pending structural tool result.`,
@@ -533,7 +543,7 @@ function structuralRequest(value){
       );
     }
   }
-  if(pendingToolCallId!==null){
+  if(pendingToolCallIds.size){
     throw new ArcaneAIError(
       "ARCANE_AI_TOOL_RESULT_REQUIRED",
       "The pending structural tool call must be settled before requesting another response.",
@@ -541,14 +551,7 @@ function structuralRequest(value){
     );
   }
 
-  return {
-    ...value,
-    ...(value.tools?.length
-      &&value.parallelToolCalls===undefined
-      &&value.parallel_tool_calls===undefined
-      ?{parallelToolCalls:false}
-      :{}),
-  };
+  return {...value};
 }
 
 function toolRecordFromCompletion(completion) {
@@ -626,79 +629,353 @@ function toolRecordFromCompletion(completion) {
     }
   }
   for (let messageIndex=0;messageIndex<messages.length;messageIndex+=1) {
+    const toolCallIds=new Set();
     const calls=structuralCallsFromMessage(
       messages[messageIndex],
       `Structural tool call message ${String(messageIndex+1)}`,
     );
-    if(messageIndex>0&&calls?.length){
-      throw new ArcaneAIError(
-        "ARCANE_AI_INVALID_PROVIDER_RESULT",
-        "The model placed a structural tool call outside the selected first choice.",
-        {operation:"request"},
-      );
-    }
     for (const [callIndex,call] of (calls ?? []).entries()) {
-      result.push(structuralToolCall(
+      const normalized=structuralToolCall(
         call,
         `Structural tool call ${String(messageIndex+1)}.${String(callIndex+1)}`,
-      ));
+      );
+      if(toolCallIds.has(normalized.id)){
+        throw new ArcaneAIError(
+          "ARCANE_AI_TOOL_CALL_INVALID",
+          "The model completion contains a duplicate structural tool-call ID.",
+          {operation:"request"},
+        );
+      }
+      toolCallIds.add(normalized.id);
+      if(messageIndex===0)result.push(normalized);
     }
   }
-  if(result.length>1){
-    throw new ArcaneAIError(
-      "ARCANE_AI_PARALLEL_TOOLS_UNSUPPORTED",
-      "The Arcane chat session accepts one structural tool call at a time.",
+  return result.length ? result : null;
+}
+
+function sameStreamedToolCalls(left,right){
+  return left.length===right.length&&left.every((call,index)=>{
+    const other=right[index];
+    return call?.id===other?.id
+      &&call?.type===other?.type
+      &&call?.function?.name===other?.function?.name
+      &&call?.function?.arguments===other?.function?.arguments;
+  });
+}
+
+function sameCompleteStreamValue(left,right,leftToRight=new Map(),rightToLeft=new Map()){
+  if(Object.is(left,right))return true;
+  if(
+    !left
+    ||!right
+    ||typeof left!=="object"
+    ||typeof right!=="object"
+    ||Array.isArray(left)!==Array.isArray(right)
+  )return false;
+  if(leftToRight.has(left)||rightToLeft.has(right)){
+    return leftToRight.get(left)===right&&rightToLeft.get(right)===left;
+  }
+  leftToRight.set(left,right);
+  rightToLeft.set(right,left);
+  const leftKeys=Reflect.ownKeys(left);
+  const rightKeys=Reflect.ownKeys(right);
+  if(leftKeys.length!==rightKeys.length)return false;
+  for(const key of leftKeys){
+    if(!Object.hasOwn(right,key))return false;
+    const leftDescriptor=Object.getOwnPropertyDescriptor(left,key);
+    const rightDescriptor=Object.getOwnPropertyDescriptor(right,key);
+    const leftIsData=Boolean(leftDescriptor&&Object.hasOwn(leftDescriptor,"value"));
+    const rightIsData=Boolean(rightDescriptor&&Object.hasOwn(rightDescriptor,"value"));
+    if(leftIsData!==rightIsData)return false;
+    if(leftIsData){
+      if(!sameCompleteStreamValue(
+        leftDescriptor.value,
+        rightDescriptor.value,
+        leftToRight,
+        rightToLeft,
+      ))return false;
+    }else if(
+      leftDescriptor?.get!==rightDescriptor?.get
+      ||leftDescriptor?.set!==rightDescriptor?.set
+    )return false;
+  }
+  return true;
+}
+
+function createStreamedToolCallAccumulator(){
+  const directChoice=Symbol("direct-stream-choice");
+  const choices=new Map();
+
+  function mismatch(message){
+    return new ArcaneAIError(
+      "ARCANE_AI_TOOL_CALL_INVALID",
+      message,
       {operation:"request"},
     );
   }
-  return result.length ? result : null;
+
+  function structuralRecord(value){
+    return plainStructuralRecord(value)&&[
+      "tool_calls",
+      "toolCalls",
+      "tool_call",
+      "toolCall",
+      "function_call",
+      "functionCall",
+    ].some((key)=>Object.hasOwn(value,key));
+  }
+
+  function choiceState(key){
+    let state=choices.get(key);
+    if(!state){
+      state={
+        completeCalls:null,
+        fragments:new Map(),
+        sawFragments:false,
+      };
+      choices.set(key,state);
+    }
+    return state;
+  }
+
+  function rememberCompleteMessage(state,message,location){
+    if(!plainStructuralRecord(message))return;
+    const structuralKeys=[
+      "tool_calls",
+      "toolCalls",
+      "tool_call",
+      "toolCall",
+      "function_call",
+      "functionCall",
+    ];
+    if(!structuralKeys.some((key)=>Object.hasOwn(message,key)))return;
+    const calls=structuralCallsFromMessage(message,location).map(
+      (call,index)=>structuralToolCall(call,`${location}.tool_calls[${String(index)}]`),
+    );
+    if(state.completeCalls&&!sameCompleteStreamValue(state.completeCalls,calls)){
+      throw mismatch("The streamed structural tool-call message changed before completion.");
+    }
+    state.completeCalls=calls;
+  }
+
+  function rememberDelta(state,delta,location){
+    if(!plainStructuralRecord(delta))return;
+    for(const key of ["toolCalls","tool_call","toolCall","function_call","functionCall"]){
+      if(Object.hasOwn(delta,key)){
+        throw mismatch(`${location} contains a noncanonical structural tool-call field.`);
+      }
+    }
+    if(!Object.hasOwn(delta,"tool_calls"))return;
+    const descriptor=Object.getOwnPropertyDescriptor(delta,"tool_calls");
+    if(!descriptor||!Object.hasOwn(descriptor,"value")||!Array.isArray(descriptor.value)){
+      throw mismatch(`${location}.tool_calls must be an array data property.`);
+    }
+    for(const [fragmentPosition,fragment] of descriptor.value.entries()){
+      if(
+        !plainStructuralRecord(fragment)
+        ||!Number.isSafeInteger(fragment.index)
+        ||fragment.index<0
+      ){
+        throw mismatch(
+          `${location}.tool_calls[${String(fragmentPosition)}] must have a valid structural call index.`,
+        );
+      }
+      const current=state.fragments.get(fragment.index)??{
+        index:fragment.index,
+        id:"",
+        type:"",
+        name:"",
+        arguments:"",
+      };
+      if(Object.hasOwn(fragment,"id")){
+        if(
+          typeof fragment.id!=="string"
+          ||!fragment.id
+          ||current.id&&current.id!==fragment.id
+        ){
+          throw mismatch("A streamed structural tool call changed or omitted its ID.");
+        }
+        current.id=fragment.id;
+      }
+      if(Object.hasOwn(fragment,"type")){
+        if(
+          typeof fragment.type!=="string"
+          ||!fragment.type
+          ||current.type&&current.type!==fragment.type
+        ){
+          throw mismatch("A streamed structural tool call changed or omitted its type.");
+        }
+        current.type=fragment.type;
+      }
+      if(Object.hasOwn(fragment,"function")){
+        if(!plainStructuralRecord(fragment.function)){
+          throw mismatch("A streamed structural tool call has an invalid function fragment.");
+        }
+        if(Object.hasOwn(fragment.function,"name")){
+          if(typeof fragment.function.name!=="string"){
+            throw mismatch("A streamed structural tool call has an invalid function-name fragment.");
+          }
+          current.name+=fragment.function.name;
+        }
+        if(Object.hasOwn(fragment.function,"arguments")){
+          if(typeof fragment.function.arguments!=="string"){
+            throw mismatch("A streamed structural tool call has an invalid arguments fragment.");
+          }
+          current.arguments+=fragment.function.arguments;
+        }
+      }
+      state.fragments.set(fragment.index,current);
+      state.sawFragments=true;
+    }
+  }
+
+  function observe(chunk){
+    if(!plainStructuralRecord(chunk))return;
+    if(structuralRecord(chunk.delta)||structuralRecord(chunk.message)){
+      const state=choiceState(directChoice);
+      rememberDelta(state,chunk.delta,"The streamed model delta");
+      rememberCompleteMessage(state,chunk.message,"The streamed model message");
+    }
+    if(!Array.isArray(chunk.choices)||!chunk.choices.length)return;
+    for(const [position,choice] of chunk.choices.entries()){
+      if(
+        !plainStructuralRecord(choice)
+        ||(!structuralRecord(choice.delta)&&!structuralRecord(choice.message))
+      )continue;
+      if(!Number.isSafeInteger(choice.index)||choice.index<0){
+        throw mismatch(
+          `The streamed model choice ${String(position)} has no valid choice index.`,
+        );
+      }
+      const state=choiceState(choice.index);
+      const location=`The streamed model choice ${String(choice.index)}`;
+      rememberDelta(state,choice.delta,`${location} delta`);
+      rememberCompleteMessage(state,choice.message,`${location} message`);
+    }
+  }
+
+  function fragmentCalls(state){
+    if(!state.sawFragments)return null;
+    const records=[...state.fragments.values()].sort((left,right)=>left.index-right.index);
+    for(let index=0;index<records.length;index+=1){
+      if(records[index].index!==index){
+        throw mismatch("The streamed structural tool calls omitted an ordered call index.");
+      }
+    }
+    return records.map((record)=>({
+      id:record.id,
+      type:record.type,
+      function:{name:record.name,arguments:record.arguments},
+    }));
+  }
+
+  function correlateChoice(state,terminalCalls){
+    const fragmentsResult=fragmentCalls(state);
+    if(
+      state.completeCalls
+      &&fragmentsResult
+      &&!sameStreamedToolCalls(state.completeCalls,fragmentsResult)
+    ){
+      throw mismatch("The streamed structural tool-call fragments do not match the streamed complete message.");
+    }
+    if(state.completeCalls&&!sameCompleteStreamValue(state.completeCalls,terminalCalls)){
+      throw mismatch("The complete streamed structural tool calls do not match the terminal completion.");
+    }
+    if(fragmentsResult&&!sameStreamedToolCalls(fragmentsResult,terminalCalls)){
+      throw mismatch("The streamed structural tool-call fragments do not match the terminal completion.");
+    }
+  }
+
+  function terminalChoices(completion){
+    const result=new Map();
+    if(typeof completion==="string")return result;
+    if(Object.hasOwn(completion,"message")){
+      result.set(
+        directChoice,
+        structuralCallsFromMessage(
+          completion.message,
+          "The terminal model message",
+        ).map(
+          (call,index)=>structuralToolCall(
+            call,
+            `The terminal model message.tool_calls[${String(index)}]`,
+          ),
+        ),
+      );
+      return result;
+    }
+    for(const choice of completion.choices){
+      result.set(
+        choice.index,
+        structuralCallsFromMessage(
+          choice.message,
+          `The terminal model choice ${String(choice.index)} message`,
+        ).map(
+          (call,index)=>structuralToolCall(
+            call,
+            `The terminal model choice ${String(choice.index)}.tool_calls[${String(index)}]`,
+          ),
+        ),
+      );
+    }
+    return result;
+  }
+
+  function correlate(completion){
+    const terminal=terminalChoices(completion);
+    for(const [key,state] of choices){
+      if(!terminal.has(key)){
+        throw mismatch(
+          "A streamed structural tool-call choice has no matching terminal completion choice.",
+        );
+      }
+      correlateChoice(state,terminal.get(key));
+    }
+  }
+
+  return {observe,correlate};
 }
 
-function isPublicStreamContentKey(key){
-  return key==="content"
-    ||key==="text"
-    ||key==="thinking"
-    ||key==="reasoning"
-    ||key==="reasoning_content";
+function isPublicStreamStructuralKey(key){
+  return key==="tool_calls"
+    ||key==="toolCalls"
+    ||key==="tool_call"
+    ||key==="toolCall"
+    ||key==="function_call"
+    ||key==="functionCall";
 }
 
-function projectPublicStreamContent(value,seen=new WeakSet()){
-  if(!value||typeof value!=="object"||seen.has(value))return null;
-  seen.add(value);
+const OMITTED_PUBLIC_STREAM_DATA=Symbol("omitted-public-stream-data");
+
+function projectPublicStreamData(value,seen=new Map()){
+  if(value===null||value===undefined||typeof value!=="object")return value;
+  if(seen.has(value))return seen.get(value);
   if(Array.isArray(value)){
     const result=[];
+    seen.set(value,result);
     for(const item of value){
-      const projected=projectPublicStreamContent(item,seen);
-      if(projected!==null)result.push(projected);
+      const projected=projectPublicStreamData(item,seen);
+      if(projected!==OMITTED_PUBLIC_STREAM_DATA)result.push(projected);
     }
-    seen.delete(value);
-    return result.length?result:null;
-  }
-  if(!plainStructuralRecord(value)){
-    seen.delete(value);
-    return null;
+    return result.length||value.length===0?result:OMITTED_PUBLIC_STREAM_DATA;
   }
   const result={};
+  seen.set(value,result);
+  let sourceDataFields=0;
   for(const [key,descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))){
     if(!Object.hasOwn(descriptor,"value"))continue;
-    if(
-      isPublicStreamContentKey(key)
-      &&descriptor.value!==null
-      &&descriptor.value!==undefined
-    ){
-      result[key]=descriptor.value;
-      continue;
-    }
-    const projected=projectPublicStreamContent(descriptor.value,seen);
-    if(projected!==null)result[key]=projected;
+    sourceDataFields+=1;
+    if(isPublicStreamStructuralKey(key))continue;
+    const projected=projectPublicStreamData(descriptor.value,seen);
+    if(projected!==OMITTED_PUBLIC_STREAM_DATA)result[key]=projected;
   }
-  seen.delete(value);
-  return Object.keys(result).length?result:null;
+  return Object.keys(result).length||sourceDataFields===0
+    ?result
+    :OMITTED_PUBLIC_STREAM_DATA;
 }
 
 function projectPublicStreamChunk(value){
-  if(typeof value==="string")return value;
-  return projectPublicStreamContent(value);
+  return projectPublicStreamData(value);
 }
 
 export class ModelController {
@@ -784,8 +1061,8 @@ export class ModelController {
     Object.defineProperty(unsubscribeModelControllerEvent, "dispose", {
       value: unsubscribeModelControllerEvent,
       enumerable: false,
-      configurable: false,
-      writable: false,
+      configurable: true,
+      writable: true,
     });
     return unsubscribeModelControllerEvent;
   }
@@ -1041,6 +1318,28 @@ export class ModelController {
     let openedIterator = null;
     let openError = null;
     let cancelPromise = null;
+    const streamedToolCalls=createStreamedToolCallAccumulator();
+    const publicChunks=[];
+    const publicChunkWaiters=[];
+    let publicStreamSettled=false;
+    let publicStreamError=null;
+
+    function publishPublicChunk(value){
+      if(publicStreamSettled)return;
+      const waiter=publicChunkWaiters.shift();
+      if(waiter)waiter.resolve({value,done:false});
+      else publicChunks.push(value);
+    }
+
+    function settlePublicStream(error=null){
+      if(publicStreamSettled)return;
+      publicStreamSettled=true;
+      publicStreamError=error;
+      for(const waiter of publicChunkWaiters.splice(0)){
+        if(error)waiter.reject(error);
+        else waiter.resolve({value:undefined,done:true});
+      }
+    }
 
     const openPromise = (async () => {
       if (linked.controller.signal.aborted) {
@@ -1115,9 +1414,41 @@ export class ModelController {
     });
     openPromise.catch(() => undefined);
 
-    const result = openPromise.then((value) => value.result).then((value) => {
+    const privateStreamPump=openPromise.then(async ()=>{
+      const streamIterator=openedIterator;
+      try{
+        while(true){
+          const next=await streamIterator.next();
+          if(next.done){
+            return true;
+          }
+          streamedToolCalls.observe(next.value);
+          const projected=projectPublicStreamChunk(next.value);
+          if(projected!==OMITTED_PUBLIC_STREAM_DATA)publishPublicChunk(projected);
+        }
+      }catch(error){
+        settlePublicStream(error);
+        throw error;
+      }
+    }).catch((error)=>{
+      settlePublicStream(error);
+      throw error;
+    });
+    privateStreamPump.catch(()=>undefined);
+
+    const terminalResult=openPromise.then((value)=>value.result).then((value)=>{
       toolRecordFromCompletion(value);
       return value;
+    });
+    terminalResult.catch(()=>undefined);
+
+    const result = Promise.all([terminalResult,privateStreamPump]).then(([terminal]) => {
+      streamedToolCalls.correlate(terminal);
+      settlePublicStream();
+      return terminal;
+    }).catch((error)=>{
+      settlePublicStream(error);
+      throw error;
     }).finally(() => {
       linked.release();
       controller.#activeStreams.delete(handle);
@@ -1129,6 +1460,10 @@ export class ModelController {
       async cancel(reason = "The stream was cancelled.") {
         cancelPromise ||= (async () => {
           linked.controller.abort(reason);
+          settlePublicStream(normalizeArcaneAIError(null,{
+            operation:"request",
+            signal:linked.controller.signal,
+          }));
           try {
             const value = opened ?? await openPromise;
             await value.cancel?.(reason);
@@ -1144,18 +1479,13 @@ export class ModelController {
         })();
         return cancelPromise;
       },
-      async next(value) {
-        if (openError) throw openError;
-        if(!opened)await openPromise;
-        const streamIterator=openedIterator;
-        let nextValue=value;
-        while(true){
-          const next=await streamIterator.next(nextValue);
-          nextValue=undefined;
-          if(next.done)return {value:undefined,done:true};
-          const projected=projectPublicStreamChunk(next.value);
-          if(projected!==null)return {value:projected,done:false};
-        }
+      async next() {
+        if(publicChunks.length)return {value:publicChunks.shift(),done:false};
+        if(publicStreamError)throw publicStreamError;
+        if(publicStreamSettled)return {value:undefined,done:true};
+        return new Promise(function waitForProjectedModelStreamChunk(resolve,reject){
+          publicChunkWaiters.push({resolve,reject});
+        });
       },
       async return(value) {
         Promise.resolve().then(()=>this.cancel(
@@ -1207,12 +1537,22 @@ export class ModelController {
     try {
       for await (const chunk of handle) {
         if (options.signal?.aborted) break;
-        for (const choice of chunk?.choices ?? []) {
+        await options.onDataChunk?.(chunk, id);
+        if(typeof chunk==="string"){
+          if(chunk)await options.onChunk?.(chunk, displayId, false);
+          continue;
+        }
+        const streamedChoices=Array.isArray(chunk?.choices)?chunk.choices:[];
+        for(const choice of streamedChoices){
           const delta = choice?.delta ?? {};
-          if (typeof delta.reasoning_content === "string" && options.seeThinking === true) {
+          if (
+            typeof delta.reasoning_content === "string"
+            &&delta.reasoning_content
+            &&options.seeThinking === true
+          ) {
             await options.onChunk?.(delta.reasoning_content, displayId, true);
           }
-          if (typeof delta.content === "string") {
+          if (typeof delta.content === "string"&&delta.content) {
             await options.onChunk?.(delta.content, displayId, false);
           }
         }
@@ -1222,13 +1562,17 @@ export class ModelController {
         throw normalizeArcaneAIError(null, { operation: "request", signal: options.signal });
       }
       const tools = toolRecordFromCompletion(completion);
+      await options.onDataResult?.(completion, id);
       if (typeof options.onResponse === "function") {
         await options.onResponse(completion, id, false);
       }
       for (const call of tools ?? []) {
         await options.onToolCall?.(call, displayId);
       }
-      const output = tools ?? textFromCompletion(completion);
+      const multipleChoices=Array.isArray(completion?.choices)&&completion.choices.length>1;
+      const output = multipleChoices
+        ?textFromCompletion(completion)
+        :tools??textFromCompletion(completion);
       if (typeof options.onComplete === "function") {
         await options.onComplete(output, displayId, false);
       }