File Coverage

blib/lib/WebService/Ollama.pm

Criterion	Covered	Total	%
statement	37	149	24.8
branch	4	58	6.9
condition	8	50	16.0
subroutine	10	24	41.6
pod	16	16	100.0
total	75	297	25.2

package WebService::Ollama;

use 5.006;
use strict;
use warnings;

our $VERSION = '0.08';

use Moo;
use Exporter 'import';

use WebService::Ollama::UA;
use JSON::Lines;

our @EXPORT_OK = qw(ollama);

# Singleton instance for functional API
my $_instance;

sub ollama {
	my ($method, @args) = @_;

	# Initialize singleton on first call
	$_instance //= __PACKAGE__->new(
		base_url => $ENV{OLLAMA_URL} // 'http://localhost:11434',
		model    => $ENV{OLLAMA_MODEL} // 'llama3.2',
	);

	# If first arg is a hashref, it's options for new instance
	if (ref($method) eq 'HASH') {
		$_instance = __PACKAGE__->new(%$method);
		return $_instance;
	}

	# Call method on singleton
	return $_instance->$method(@args);
}

has json => (
	is => 'ro',
	default => sub {
		JSON::Lines->new( utf8 => 1 );
	}
);

has base_url => (
	is => 'ro',
	required => 1,
	lazy => 1,
);

has model => (
	is => 'ro',
);

has ua => (
	is => 'ro',
	lazy => 1,
	default => sub {
		return WebService::Ollama::UA->new(
			base_url => $_[0]->base_url
		);
	}
);

has tools => (
	is => 'ro',
	default => sub { {} },
);

sub register_tool {
	my ($self, %args) = @_;

	my $name = $args{name} or die "Tool name required";
	my $description = $args{description} // '';
	my $parameters = $args{parameters} // { type => 'object', properties => {} };
	my $handler = $args{handler} or die "Tool handler required";

	$self->tools->{$name} = {
		name        => $name,
		description => $description,
		parameters  => $parameters,
		handler     => $handler,
	};

	return $self;
}

sub _format_tools_for_api {
	my ($self, $tools) = @_;

	$tools //= $self->tools;
	return [] unless keys %$tools;

	return [
		map {
			{
				type     => 'function',
				function => {
					name        => $_->{name},
					description => $_->{description},
					parameters  => $_->{parameters},
				},
			}
		} values %$tools
	];
}

sub version {
	my ($self, %args) = @_;

	return $self->ua->get(url => '/api/version');
}

sub create_model {
	my ($self, %args) = @_;

	if (! $args{model}) {
		die "No model defined for create_model";
	}

	return $self->ua->post(
		url => '/api/create',
		data => \%args
	);
}

sub copy_model {
	my ($self, %args) = @_;

	if (! $args{source}) {
		die "No source defined for copy_model";
	}


	if (! $args{destination}) {
		die "No destination defined for copy_model";
	}

	return $self->ua->post(
		url => '/api/create',
		data => \%args
	);
}

sub delete_model {
	my ($self, %args) = @_;

	if (! $args{model}) {
		die "No model defined for create_model";
	}

	return $self->ua->delete(
		url => '/api/delete',
		data => \%args
	);
}


sub available_models {
	my ($self, %args) = @_;

	return $self->ua->get(url => '/api/tags');
}

sub running_models {
	my ($self, %args) = @_;

	return $self->ua->get(url => '/api/ps');
}

sub load_completion_model {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for load_completion_model";
	}

	return $self->ua->post(
		url => '/api/generate',
		data => \%args
	);
}

sub unload_completion_model {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for unload_completion_model";
	}

	$args{keep_alive} = 0;

	return $self->ua->post(
		url => '/api/generate',
		data => \%args
	);
}

sub completion {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for completion";
	}

	if (! $args{prompt}) {
		die "No prompt defined for completion";
	}

	$args{stream} = $args{stream} ? \1 : \0;

	if ( defined $args{image_files} ) {
		$args{images} = [];
		push @{$args{images}}, @{ $self->ua->base64_images(delete $args{image_files}) };
	}

	return $self->ua->post(
		url => '/api/generate',
		data => \%args
	);
}

sub load_chat_model {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for load_chat_model";
	}

	$args{messages} = [];

	return $self->ua->post(
		url => '/api/chat',
		data => \%args
	);
}

sub unload_chat_model {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for unload_chat_model";
	}

	$args{keep_alive} = 0;
	$args{messages} = [];

	return $self->ua->post(
		url => '/api/generate',
		data => \%args
	);
}

sub chat {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for chat";
	}

	if (! $args{messages}) {
		die "No messsages defined for chat";
	}

	$args{stream} = $args{stream} ? \1 : \0;

	for my $message (@{$args{messages}}) {
		if ($message->{image_files}) {
			$message->{images} = [];
			push @{$message->{images}}, @{ $self->ua->base64_images(delete $message->{image_files}) };
		}
	}

	return $self->ua->post(
		url => '/api/chat',
		data => \%args
	);
}

sub embed {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for embed";
	}

	return $self->ua->post(
		url => '/api/embed',
		data => \%args
	);
}

# ============================================
# TOOL EXECUTION
# ============================================

sub chat_with_tools {
	my ($self, %args) = @_;

	$args{model} //= $self->model;

	if (! $args{model}) {
		die "No model defined for chat_with_tools";
	}

	if (! $args{messages}) {
		die "No messages defined for chat_with_tools";
	}

	my $max_iterations = $args{max_iterations} // 10;
	my @messages = @{$args{messages}};
	my @all_responses;

	# Add tools to request
	my $tools = $args{tools} // $self->_format_tools_for_api;

	for my $iteration (1 .. $max_iterations) {
		my $response = $self->chat(
			model    => $args{model},
			messages => \@messages,
			tools    => $tools,
			stream   => 0,
		);

		push @all_responses, $response;

		# Check if model wants to call tools
		my $tool_calls = $response->extract_tool_calls;

		if (!@$tool_calls) {
			# No tool calls - return final response
			last;
		}

		# Add assistant message with tool calls
		push @messages, {
			role       => 'assistant',
			content    => $response->message->{content} // '',
			tool_calls => $tool_calls,
		};

		# Execute each tool and add results
		for my $tool_call (@$tool_calls) {
			my $function = $tool_call->{function};
			my $tool_name = $function->{name};
			my $tool_args = $function->{arguments};

			# Parse arguments if string
			if (!ref($tool_args)) {
				$tool_args = eval { $self->json->decode($tool_args)->[0] } // {};
			}

			my $result;
			if (my $handler = $self->tools->{$tool_name}{handler}) {
				$result = eval { $handler->($tool_args) };
				if ($@) {
					$result = "Error executing tool: $@";
				}
			} else {
				$result = "Unknown tool: $tool_name";
			}

			# Add tool result message
			push @messages, {
				role         => 'tool',
				content      => ref($result) ? $self->json->encode([$result]) : "$result",
				tool_call_id => $tool_call->{id} // $tool_name,
			};
		}
	}

	# Return last response (or all if needed)
	return wantarray ? @all_responses : $all_responses[-1];
}

1;

__END__