Method handle_tool_call

aiscript-vm/src/ai/agent.rs:202–253

(
        &self,
        state: &mut State<'gc>,
        tool_calls: &Option<Vec<ToolCall>>,
    )

    }

    fn handle_tool_call(
        &self,
        state: &mut State<'gc>,
        tool_calls: &Option<Vec<ToolCall>>,
    ) -> Result<Response<'gc>, String> {
        let mut response = Response::default();
        for tool_call in tool_calls.as_ref().unwrap() {
            let name = tool_call.function.name.as_ref().unwrap();
            if let Some(tool_def) = self.tools.get(name) {
                let arguments = serde_json::from_str::<serde_json::Value>(
                    tool_call.function.arguments.as_ref().unwrap(),
                )
                .unwrap();
                // Pass params as positional arguments
                let params = tool_def
                    .params
                    .keys()
                    .filter_map(|key| {
                        arguments
                            .get(key)
                            .map(|v| Value::String(state.intern(v.as_str().unwrap().as_bytes())))
                    })
                    .collect::<Vec<_>>();
                let result = state
                    .eval_function_with_id(tool_def.chunk_id, &params)
                    .unwrap();
                // println!(
                //     "call tool {name} params: {:?}, result: {}",
                //     params.iter().map(|i| format!("{i}")).collect::<Vec<_>>(),
                //     result
                // );
                let content = if let Value::Agent(agent) = result {
                    let agent_name = agent.name;
                    response.agent = state.get_global(agent_name).map(|v| v.as_agent().unwrap());
                    format!("{{\"assistant\": {}}}", agent_name)
                } else {
                    result.to_string()
                };
                response.messages.push(ChatCompletionMessage {
                    role: MessageRole::tool,
                    content: Content::Text(content),
                    name: tool_call.function.name.clone(),
                    tool_calls: None,
                    tool_call_id: Some(tool_call.id.clone()),
                });
            } else {
                return Err(format!("Warning: unknow tool function: {name}"));
            }
        }

        Ok(response)
    }
}

#[cfg(feature = "ai_test")]