descry-tool-core 0.3.1

Core traits and types for descry-tool framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Multi-protocol adapter example
//!
//! Demonstrates how to use different protocol adapters (MCP, OpenAI, Anthropic).

use descry_tool_core::{
    adapters::{AnthropicAdapter, McpAdapter, OpenAiAdapter, ToolAdapter},
    tool_names, ToolContext, ToolError,
};
use descry_tool_macros::tool;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::sync::Arc;

// Define a tool
#[derive(Deserialize, JsonSchema)]
struct GreetParams {
    name: String,
    #[serde(default)]
    formal: bool,
}

#[derive(Serialize, JsonSchema)]
struct GreetOutput {
    greeting: String,
}

#[tool(
    name = "greet",
    description = "Generate a greeting message"
)]
async fn greet(_ctx: Arc<ToolContext>, params: GreetParams) -> Result<GreetOutput, ToolError> {
    let greeting = if params.formal {
        format!("Good day, {}!", params.name)
    } else {
        format!("Hi, {}!", params.name)
    };
    
    Ok(GreetOutput { greeting })
}

#[tokio::main]
async fn main() {
    println!("=== Multi-Protocol Adapter Example ===\n");

    // Get all registered tools
    let names = tool_names();
    println!("Registered tools: {:?}\n", names);

    // Get the greet tool metadata
    let meta = descry_tool_core::find_tool("greet").unwrap();

    // 1. MCP Format
    println!("1. MCP (Model Context Protocol) Format:");
    let mcp_spec = McpAdapter::to_spec(meta);
    println!("{}\n", serde_json::to_string_pretty(&mcp_spec).unwrap());

    // 2. OpenAI Format
    println!("2. OpenAI Function Calling Format:");
    let openai_spec = OpenAiAdapter::to_spec(meta);
    println!("{}\n", serde_json::to_string_pretty(&openai_spec).unwrap());

    // 3. Anthropic Format
    println!("3. Anthropic (Claude) Format:");
    let anthropic_spec = AnthropicAdapter::to_spec(meta);
    println!("{}\n", serde_json::to_string_pretty(&anthropic_spec).unwrap());

    // Show response conversion
    println!("=== Response Conversion ===\n");
    
    let output = serde_json::json!({"greeting": "Hi, Dave!"});
    
    println!("MCP Response:");
    let mcp_resp = McpAdapter::to_response(output.clone());
    println!("{}\n", serde_json::to_string_pretty(&mcp_resp).unwrap());

    println!("OpenAI Response:");
    let openai_resp = OpenAiAdapter::to_response_with_id(output.clone(), "call_789".to_string());
    println!("{}\n", serde_json::to_string_pretty(&openai_resp).unwrap());

    println!("Anthropic Response:");
    let anthropic_resp = AnthropicAdapter::to_response_with_id(output.clone(), "toolu_012".to_string());
    println!("{}\n", serde_json::to_string_pretty(&anthropic_resp).unwrap());

    // Demonstrate generating tool lists for all protocols
    println!("=== Generate Tool Lists for Different Protocols ===\n");
    
    // MCP tools
    let mcp_tools: Vec<_> = descry_tool_core::all_tools()
        .map(|meta| McpAdapter::to_spec(meta))
        .collect();
    println!("MCP Tools: {} tools available", mcp_tools.len());
    for tool in &mcp_tools {
        println!("  - {}", tool.name);
    }
    println!();

    // OpenAI tools
    let openai_tools: Vec<_> = descry_tool_core::all_tools()
        .map(|meta| OpenAiAdapter::to_spec(meta))
        .collect();
    println!("OpenAI Tools: {} tools available", openai_tools.len());
    for tool in &openai_tools {
        println!("  - {}", tool.function.name);
    }
    println!();

    // Anthropic tools
    let anthropic_tools: Vec<_> = descry_tool_core::all_tools()
        .map(|meta| AnthropicAdapter::to_spec(meta))
        .collect();
    println!("Anthropic Tools: {} tools available", anthropic_tools.len());
    for tool in &anthropic_tools {
        println!("  - {}", tool.name);
    }
}