@atgs/tapeworm 0.0.1 → 0.0.2

package/dist/agent/agent.d.ts

@@ -0,0 +1,17 @@
+import Conversation, { ConversationManager } from "../conversation/conversation";
+import { ModelResponse, type Model } from "../model/model";
+import type Tool from "../tool/tool";
+import type ToolCall from "../tool/toolCall";
+export default class Agent {
+    name: string;
+    system_prompt?: string;
+    tools: Tool[];
+    model: Model;
+    conversation: Conversation;
+    conversationManager?: ConversationManager;
+    toolNameToIndexMap: any | undefined;
+    invoke(query: string): Promise<void>;
+    _runQuery(): Promise<ModelResponse>;
+    _runTool(toolCall: ToolCall): Promise<any>;
+    generateToolNameToIndexMap(): void;
+}

package/dist/conversation/conversation.d.ts

@@ -0,0 +1,41 @@
+import type { Model } from "../model/model";
+import type ToolCall from "../tool/toolCall";
+export default class Conversation {
+    messages: Message[];
+    manager: ConversationManager;
+    constructor();
+    append(message: Message): void;
+}
+export declare class Message {
+    role: string;
+    content?: any;
+    toolCalls?: ToolCall[];
+    toolName?: string;
+    thinking?: string;
+    constructor(role: string, content: any, toolCalls: any[] | undefined, toolName: string | undefined, thinking: string | undefined);
+    setRole(role: string): void;
+    setContent(content: any): void;
+    setToolCalls(toolCalls: any): void;
+    static builder(): MessageBuilder;
+}
+export declare class MessageBuilder {
+    private _role;
+    private _content?;
+    private _toolCalls?;
+    private _toolName?;
+    private _thinking?;
+    role(role: string): MessageBuilder;
+    content(content: any): MessageBuilder;
+    toolCalls(toolCalls: ToolCall[]): MessageBuilder;
+    toolName(toolName: any): MessageBuilder;
+    thinking(thinking: string | undefined): MessageBuilder;
+    build(): Message;
+}
+export declare class ConversationManager {
+    compact(conversation: Message[]): Message[];
+    configure(model: Model): void;
+}
+export declare class DefaultConversationManager extends ConversationManager {
+    compact(conversation: Message[]): Message[];
+    configure(_model: Model): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Agent } from './agent/agent';
+export { default as Conversation, Message, MessageBuilder, ConversationManager, DefaultConversationManager } from './conversation/conversation';
+export { Model, ModelRequest, ModelRequestBuilder, ModelResponse, ModelResponseBuilder } from './model/model';
+export { default as Tool } from './tool/tool';
+export { default as ToolCall, ToolCallBuilder } from './tool/toolCall';
+export { default as ToolSchema, ToolSchemaBuilder, Parameter, ParameterBuilder } from './tool/toolschema';
+export { default as OllamaModel } from './model/OllamaModel';

package/dist/model/OllamaModel.d.ts

@@ -0,0 +1,27 @@
+import { Model, ModelRequest, ModelResponse } from "./model";
+export default class OllamaModel extends Model {
+    endpoint: string;
+    model: string;
+    options?: any;
+    /**
+     * Create a model wrapper for an Ollama chat endpoint.
+     * @param endpoint Base URL of the Ollama server (e.g., http://localhost:11434).
+     * @param model Model name/tag to use for inference.
+     * @param options Additional Ollama options passed through to the API.
+     */
+    constructor(endpoint: string, model: string, options: any);
+    /**
+     * Call the Ollama chat API with the provided conversation and tools.
+     * Formats the request, performs the HTTP POST, and translates the response into a ModelResponse.
+     */
+    invoke(request: ModelRequest): Promise<ModelResponse>;
+    /**
+     * Convert internal tool definitions into the JSON schema format expected by Ollama.
+     */
+    _formatTools(request: ModelRequest): any;
+    /**
+     * Convert internal message objects into Ollama's chat message shape.
+     * Passes through assistant/system/user roles and maps tool role into the expected structure.
+     */
+    _formatMessages(request: ModelRequest): any;
+}

package/dist/model/model.d.ts

@@ -0,0 +1,84 @@
+import type { Message } from "../conversation/conversation";
+import type Tool from "../tool/tool";
+import type ToolCall from "../tool/toolCall";
+/**
+ * A Model represents the LLM backend for the agent.
+ */
+export declare class Model {
+    /**
+     * Execute the model against the provided request.
+     * @param request Aggregated messages and tools to send to the model.
+     */
+    invoke(request: ModelRequest): Promise<ModelResponse>;
+    /**
+     * Return the maximum token budget supported by this model.
+     */
+    tokenLimit(): void;
+}
+export declare class ModelRequest {
+    messages: Message[];
+    tools: Tool[];
+    /**
+     * Create a new model request envelope.
+     * @param messages Conversation history to send to the model.
+     * @param tools Tool definitions available for function calling.
+     */
+    constructor(messages: Message[], tools: Tool[]);
+    static builder(): ModelRequestBuilder;
+}
+export declare class ModelRequestBuilder {
+    private _messages;
+    private _tools;
+    /**
+     * Supply the conversation messages to include.
+     */
+    messages(messages: Message[]): ModelRequestBuilder;
+    /**
+     * Supply the tool list for this request.
+     */
+    tools(tools: Tool[]): ModelRequestBuilder;
+    /**
+     * Build the ModelRequest, defaulting tools to an empty array.
+     */
+    build(): ModelRequest;
+}
+export declare class ModelResponse {
+    toolCalls?: ToolCall[];
+    role?: string;
+    content?: string;
+    thinking?: string;
+    /**
+     * Wrap a model response.
+     * @param toolCalls Optional tool calls returned by the model.
+     * @param role Role of the message (e.g., assistant, tool).
+     * @param content Text content returned by the model.
+     */
+    constructor(toolCalls: ToolCall[], role: string | undefined, content: string | undefined, thinking: string | undefined);
+    static builder(): ModelResponseBuilder;
+}
+export declare class ModelResponseBuilder {
+    private _toolCalls;
+    private _role?;
+    private _content?;
+    private _thinking?;
+    /**
+     * Attach tool calls to the response.
+     */
+    toolCalls(toolCalls: ToolCall[]): ModelResponseBuilder;
+    /**
+     * Set the role for the response message.
+     */
+    role(role: string): ModelResponseBuilder;
+    /**
+     * Set the textual content for the response message.
+     */
+    content(content: string): ModelResponseBuilder;
+    /**
+     * Set the thinking content for the response message.
+     */
+    thinking(thinking: string): ModelResponseBuilder;
+    /**
+     * Build the ModelResponse from the collected fields.
+     */
+    build(): ModelResponse;
+}

package/dist/tool/tool.d.ts

@@ -0,0 +1,15 @@
+import type ToolSchema from "./toolschema";
+/**
+ * The Tool class represents a tool that a Tapeworm agent can use.
+ *
+ */
+export default class Tool {
+    private name;
+    private description;
+    private tool_schema;
+    constructor();
+    getName(): string;
+    getDescription(): string;
+    getToolSchema(): ToolSchema;
+    execute(input: any): any;
+}

package/dist/tool/toolCall.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Represents a single tool invocation returned by a model, including the target
+ * tool name, argument map, type (function/spec), and optional sequence number.
+ */
+export default class ToolCall {
+    sequence: number | undefined;
+    name: string;
+    parameters: any;
+    type: string;
+    constructor(sequence: number | undefined, name: string, parameters: any, type: string);
+    static builder(): ToolCallBuilder;
+}
+/**
+ * Fluent builder for constructing ToolCall instances from model output.
+ */
+export declare class ToolCallBuilder {
+    private _sequence;
+    private _name;
+    private _parameters;
+    private _type;
+    sequence(sequence: number | undefined): ToolCallBuilder;
+    name(name: string): this;
+    parameters(parameters: any): ToolCallBuilder;
+    type(type: string): ToolCallBuilder;
+    build(): ToolCall;
+}

package/dist/tool/toolschema.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tool schemas specify the input and output of a tool.
+ */
+export default class ToolSchema {
+    parameters: Parameter[];
+    output: string;
+    /**
+     * Create a new tool schema.
+     * @param parameters Ordered list of input parameters the tool accepts.
+     * @param output Human-readable description of the tool output.
+     */
+    constructor(parameters: Parameter[], output: string);
+    /**
+     * Return a tool schema builder, so you can properly construct tools instead of dealing with the constructor
+     * @returns a tool schema builder.
+     */
+    static builder(): ToolSchemaBuilder;
+}
+/**
+ * A builder for tool schemas
+ */
+export declare class ToolSchemaBuilder {
+    private _parameters;
+    private _output;
+    /**
+     * Add a parameter definition to the schema.
+     * @param parameter Fully constructed parameter to append.
+     */
+    addParameter(parameter: Parameter): ToolSchemaBuilder;
+    /**
+     * Describe the output of the tool.
+     * @param output Text description of what the tool returns.
+     */
+    output(output: string): ToolSchemaBuilder;
+    /**
+     * Build the ToolSchema instance from the collected fields.
+     */
+    build(): ToolSchema;
+}
+/**
+ * A Parameter for a tool.
+ * Includes:
+ * - The name of the parameter
+ * - What the parameter is used for
+ * - The type of the parameter
+ */
+export declare class Parameter {
+    name: string;
+    description: string;
+    type: string;
+    required: boolean;
+    /**
+     * Create a new parameter definition.
+     * @param name Identifier for the parameter.
+     * @param description Explanation of how the parameter is used.
+     * @param type JSON-serializable type name (e.g., string, number).
+     * @param required Whether the parameter must be provided.
+     */
+    constructor(name: string, description: string, type: string, required: boolean);
+    /**
+     * Placeholder for validating supported parameter types.
+     */
+    assertValidType(): void;
+    static builder(): ParameterBuilder;
+}
+export declare class ParameterBuilder {
+    private _name;
+    private _description;
+    private _type;
+    private _required?;
+    /**
+     * Set the parameter name.
+     */
+    name(name: string): ParameterBuilder;
+    /**
+     * Set the parameter description.
+     */
+    description(description: string): ParameterBuilder;
+    /**
+     * Set the parameter type.
+     */
+    type(type: string): ParameterBuilder;
+    /**
+     * Mark the parameter as required or optional.
+     */
+    required(required: boolean): ParameterBuilder;
+    /**
+     * Build a Parameter instance using the accumulated fields.
+     */
+    build(): Parameter;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atgs/tapeworm",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "dist/tapeworm.cjs.js",
   "module": "dist/tapeworm.es.js",
@@ -10,7 +10,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "vite build",
+    "build": "vite build && npm run build:types",
+    "build:types": "tsc -p tsconfig.types.json",
     "test": "jest"
   },
   "devDependencies": {