Written in Rust,
extensible in any language,
and fast.

from octet_extension import Extension

ext = Extension(api_version="0.4")


@ext.tool(
    name="hello",
    description="Say hello to someone",
    parameters={
        "type": "object",
        "properties": {"name": {"type": "string"}},
        "required": ["name"],
        "additionalProperties": False,
    },
)
def hello(args):
    return f"Hello, {args['name']}!"


ext.run()

import { Extension } from '@skaft-software/octet-extension-sdk';

const extension = new Extension();
extension.tool({
  name: 'hello',
  description: 'Say hello to someone',
  parameters: {
    type: 'object',
    properties: { name: { type: 'string' } },
    required: ['name'],
    additionalProperties: false,
  },
}, ({ name }) => `Hello, ${name}!`);
export default extension;

use octet_extension::{Deserialize, Extension, JsonSchema, ToolResult};

#[derive(Deserialize, JsonSchema)]
struct Hello {
    name: String,
}

fn main() -> Result<(), octet_extension::Error> {
    let mut extension = Extension::new();
    extension.tool("hello", "Say hello to someone", |args: Hello, _call| {
        Ok(ToolResult::text(format!("Hello, {}!", args.name)))
    })?;
    extension.run()
}

#include <octet.hpp>

int main() {
    octet::extension extension;
    extension.tool("hello", "Say hello to someone", {octet::field::string("name", 256)},
                   [](octet::call &call) {
                       return octet::result::text("Hello, " + call.string("name") + "!");
                   });
    extension.run();
}

use strict;
use warnings;
use JSON::PP;

$| = 1;
my $json = JSON::PP->new;
while (my $line = <STDIN>) {
    my $request = decode_json($line);
    my ($id, $method) = @$request{qw(id method)};
    my $result =
        $method eq 'initialize' ? {
            api_version => '0.1',
            commands    => [],
            tools       => [{
                name        => 'hello',
                description => 'Say hello to someone',
                parameters  => {
                    type                 => 'object',
                    properties           => { name => { type => 'string' } },
                    required             => ['name'],
                    additionalProperties => JSON::PP::false,
                },
            }],
        }
      : $method eq 'tool/call' ? {
            content  => "Hello, $request->{params}{arguments}{name}!",
            is_error => JSON::PP::false,
        }
      : {};
    print $json->encode({ jsonrpc => '2.0', id => $id, result => $result }), "\n" if defined $id;
    last if $method eq 'shutdown';
}