@atgs/tapeworm 0.0.2 → 0.1.1

package/dist/tapeworm.es.js

@@ -1,96 +1,286 @@
-class w {
+class b {
   messages;
   manager;
+  /**
+   * Initialize an empty conversation using the default manager.
+   */
   constructor() {
-    this.messages = [], this.manager = new T();
+    this.messages = [], this.manager = new f();
   }
+  /**
+   * Append a message to the history and apply compaction rules.
+   * @param message Message to store.
+   */
   append(e) {
     this.messages.push(e), this.messages = this.manager.compact(this.messages);
   }
 }
-class a {
-  role;
-  content;
-  toolCalls;
-  toolName;
-  thinking;
-  constructor(e, s, t, o, i) {
-    this.role = e, this.content = s, this.toolCalls = t, this.toolName = o, this.thinking = i;
+class C {
+  /**
+   * Compact or adjust a conversation according to a strategy.
+   * @param conversation Full list of messages so far.
+   * @returns Adjusted message list to keep.
+   */
+  compact(e) {
+    throw new p(
+      "No implementation for conversation manager!"
+    );
+  }
+  /**
+   * Allow the manager to consider model-specific constraints (e.g., token limits).
+   * @param model Model being used for this conversation.
+   */
+  configure(e) {
+    throw new p(
+      "No implementation for conversation manager!"
+    );
   }
-  setRole(e) {
-    this.role = e;
+}
+class f extends C {
+  /**
+   * Default strategy simply returns the conversation untouched.
+   */
+  compact(e) {
+    return e;
   }
-  setContent(e) {
-    this.content = e;
+  /**
+   * Default manager ignores model configuration because it does no compaction.
+   */
+  configure(e) {
   }
-  setToolCalls(e) {
-    this.toolCalls = e;
+}
+class p extends Error {
+  constructor(e) {
+    super(e), this.name = "ConversationManagerNotImplemented";
   }
+}
+class h {
+  role;
+  content;
+  /**
+   * Wrap a set of message components with an associated sender role.
+   * @param role Source of the message (e.g., user, assistant, tool).
+   * @param content Ordered list of message components that make up the message body.
+   */
+  constructor(e, t) {
+    this.role = e, this.content = t;
+  }
+  /**
+   * Create a new message builder for ergonomic construction.
+   * @returns A MessageBuilder instance.
+   */
   static builder() {
-    return new b();
+    return new N();
+  }
+  /**
+   * Filters the message contents based on the message type.
+   */
+  filter(e) {
+    return this.content.filter((t) => t.getMessageComponentType() == e);
   }
 }
-class b {
+class N {
   _role;
   _content;
-  _toolCalls;
-  _toolName;
-  _thinking;
+  /**
+   * Set the role associated with the message being built.
+   * @param role Source of the message (e.g., user, assistant, tool).
+   * @returns This builder for chaining.
+   */
   role(e) {
     return this._role = e, this;
   }
-  content(e) {
-    return this._content = e, this;
+  /**
+   * Ensure the content array is initialized before appending components.
+   */
+  init() {
+    this._content == null && (this._content = []);
   }
+  /**
+   * Attach a tool call component if provided.
+   * @param toolCall Tool call to append to the message.
+   * @returns This builder for chaining.
+   */
+  toolCall(e) {
+    return e == null ? this : (this.init(), this._content.push(e), this);
+  }
+  /**
+   * Attach SEVERAL tool call component if provided.
+   * @param toolCall Tool call to append to the message.
+   * @returns This builder for chaining.
+   */
   toolCalls(e) {
-    return this._toolCalls = e, this;
+    if (e == null)
+      return this;
+    this.init();
+    for (const t of e)
+      this._content.push(t);
+    return this;
   }
-  toolName(e) {
-    return this._toolName = e, this;
+  /**
+   * Attach a tool result component if provided.
+   * @param toolResult Result of a previously executed tool call.
+   * @returns This builder for chaining.
+   */
+  toolResult(e) {
+    return e == null ? this : (this.init(), this._content.push(e), this);
   }
+  /**
+   * Attach a thinking component if provided.
+   * @param thinking Reflection or chain-of-thought text.
+   * @returns This builder for chaining.
+   */
   thinking(e) {
-    return this._thinking = e, this;
+    return e == null ? this : (this.init(), this._content.push(k.of(e)), this);
   }
+  /**
+   * Attach content to the message if provided.
+   * @param content Assistant or user text content.
+   * @returns This builder for chaining.
+   */
+  content(e) {
+    return e == null ? this : (this.init(), this._content.push(x.of(e)), this);
+  }
+  /**
+   * Construct the Message with the accumulated values.
+   * @returns Finalized Message instance.
+   */
   build() {
-    return new a(this._role, this._content, this._toolCalls, this._toolName, this._thinking);
+    if (this._content == null || this._content.length == 0)
+      throw new Error("Role-only messages are not supported by Tapeworm.");
+    return new h(this._role, this._content);
   }
 }
-class v {
-  compact(e) {
-    throw new m("No implementation for conversation manager!");
-  }
-  configure(e) {
-    throw new m("No implementation for conversation manager!");
+const l = {
+  Content: "content",
+  Thinking: "thinking",
+  ToolCall: "toolcall",
+  ToolResult: "toolresult"
+};
+class u {
+  /**
+   * Get the type of this message component, as defined in MessageComponentType
+   */
+  getMessageComponentType() {
+    throw new Error(
+      "Message components that do not have a message component type are not allowed."
+    );
   }
 }
-class T extends v {
-  compact(e) {
-    return e;
+class x extends u {
+  text;
+  /**
+   * Create a content component with the provided text.
+   * @param text Body of the content block.
+   */
+  constructor(e) {
+    super(), this.text = e;
   }
-  configure(e) {
+  /**
+   * Get the type of this message component, as defined in MessageComponentType.
+   * This returns MessageComponentType.Content.
+   */
+  getMessageComponentType() {
+    return l.Content;
+  }
+  /**
+   * Get the content of this MessageComponent.
+   * @returns the string contained in this component.
+   */
+  get() {
+    return this.text;
+  }
+  /**
+   * Shorthand for the constructor
+   * @param text - the text this content block represents.
+   * @returns a new Content messagecomponent with the text.
+   */
+  static of(e) {
+    return new this(e);
   }
 }
-class m extends Error {
+class k extends u {
+  thought;
+  /**
+   * Create a thinking component with the provided thought text.
+   * @param thought Chain-of-thought or reasoning string.
+   */
   constructor(e) {
-    super(e), this.name = "ConversationManagerNotImplemented";
+    super(), this.thought = e;
+  }
+  /**
+   * Get the type of this message component, as defined in MessageComponentType.
+   * This returns MessageComponentType.Content.
+   */
+  getMessageComponentType() {
+    return l.Thinking;
+  }
+  /**
+   * Get the content of this MessageComponent.
+   * @returns the string contained in this component.
+   */
+  get() {
+    return this.thought;
+  }
+  /**
+   * Shorthand for the constructor
+   * @param thought - the text this content block represents.
+   * @returns a new Thinking message component with the text.
+   */
+  static of(e) {
+    return new this(e);
   }
 }
-class N {
+class m extends u {
+  id;
+  toolName;
+  toolResult;
+  /**
+   * Create a tool result component for a completed tool call.
+   * @param id Identifier of the originating tool call.
+   * @param toolName Name of the tool that produced the result.
+   * @param toolResult Output returned by the tool.
+   */
+  constructor(e, t, o) {
+    super(), this.id = e, this.toolName = t, this.toolResult = o;
+  }
+  /**
+   * Get the type of this message component, as defined in MessageComponentType.
+   * This returns MessageComponentType.ToolResult.
+   */
+  getMessageComponentType() {
+    return l.ToolResult;
+  }
+  /**
+   * Shorthand for the constructor
+   * @param toolCall Original tool call that produced this result.
+   * @param toolResult Output to attach to the tool result component.
+   * @returns a new ToolResult component mirroring the provided tool call.
+   */
+  static of(e, t) {
+    return new this(e.id, e.name, t);
+  }
+}
+class q {
   /**
    * Execute the model against the provided request.
    * @param request Aggregated messages and tools to send to the model.
    */
   async invoke(e) {
-    throw new u("The invoke function for this model was not correctly implemented.");
+    throw new g(
+      "The invoke function for this model was not correctly implemented."
+    );
   }
   /**
    * Return the maximum token budget supported by this model.
    */
   tokenLimit() {
-    throw new u("The tokenLimit function for this model was not correctly implemented.");
+    throw new g(
+      "The tokenLimit function for this model was not correctly implemented."
+    );
   }
 }
-class C {
+class E {
   messages;
   tools;
   /**
@@ -98,146 +288,233 @@ class C {
    * @param messages Conversation history to send to the model.
    * @param tools Tool definitions available for function calling.
    */
-  constructor(e, s) {
-    this.messages = e, this.tools = s;
+  constructor(e, t) {
+    this.messages = e, this.tools = t;
   }
+  /**
+   * Create a builder for composing a model request.
+   * @returns A ModelRequestBuilder instance.
+   */
   static builder() {
-    return new d();
+    return new _();
   }
 }
-class d {
+class _ {
   _messages;
   _tools;
   /**
    * Supply the conversation messages to include.
+   * @returns This builder for chaining.
    */
   messages(e) {
     return this._messages = e, this;
   }
   /**
    * Supply the tool list for this request.
+   * @returns This builder for chaining.
    */
   tools(e) {
     return this._tools = e, this;
   }
   /**
    * Build the ModelRequest, defaulting tools to an empty array.
+   * @returns Constructed ModelRequest.
    */
   build() {
-    return this._tools == null && (this._tools = []), new C(this._messages, this._tools);
+    if (this._tools == null && (this._tools = []), this._messages == null)
+      throw new R(
+        "Requests to the model should include content."
+      );
+    return new E(this._messages, this._tools);
   }
 }
-class M {
-  toolCalls;
-  role;
-  content;
-  thinking;
+class g extends Error {
+  constructor(e) {
+    super(e), this.name = "ModelNotImplementedError";
+  }
+}
+class R extends Error {
+  constructor(e) {
+    super(e), this.name = "MessagesNotDefinedError";
+  }
+}
+class v extends u {
+  sequence;
+  name;
+  parameters;
+  type;
+  id;
+  /**
+   * Get the type of this message component, as defined in MessageComponentType.
+   * This returns MessageComponentType.ToolCall.
+   */
+  getMessageComponentType() {
+    return l.ToolCall;
+  }
   /**
-   * 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.
+   * Create a ToolCall component to represent a model-requested tool invocation.
+   * @param sequence Optional ordering from the model for batched tool calls.
+   * @param name Name of the tool to invoke.
+   * @param parameters Arguments provided by the model.
+   * @param type Type of tool call (e.g., function).
+   * @param id Provider-generated identifier for correlating results.
    */
-  constructor(e, s, t, o) {
-    this.toolCalls = e, this.role = s, this.content = t, this.thinking = o;
+  constructor(e, t, o, s, i) {
+    super(), this.sequence = e, this.name = t, this.parameters = o, this.type = s, this.id = i;
   }
+  /**
+   * Convenience factory for a ToolCallBuilder.
+   * @returns A new ToolCallBuilder instance.
+   */
   static builder() {
-    return new p();
+    return new P();
   }
 }
-class p {
-  _toolCalls;
-  _role;
-  _content;
-  _thinking;
+class P {
+  _sequence;
+  _name;
+  _parameters;
+  _type;
+  _id;
   /**
-   * Attach tool calls to the response.
+   * Set the sequence number for the tool call.
+   * @param sequence Optional position of the tool call in a batch.
+   * @returns This builder for chaining.
    */
-  toolCalls(e) {
-    return this._toolCalls = e, this;
+  sequence(e) {
+    return this._sequence = e, this;
   }
   /**
-   * Set the role for the response message.
+   * Set the name of the tool to invoke.
+   * @param name Tool identifier.
+   * @returns This builder for chaining.
    */
-  role(e) {
-    return this._role = e, this;
+  name(e) {
+    return this._name = e, this;
   }
   /**
-   * Set the textual content for the response message.
+   * Provide the argument payload for the tool call.
+   * @param parameters JSON-serializable arguments to pass to the tool.
+   * @returns This builder for chaining.
    */
-  content(e) {
-    return this._content = e, this;
+  parameters(e) {
+    return this._parameters = e, this;
   }
   /**
-   * Set the thinking content for the response message.
+   * Set the type of tool call (e.g., function).
+   * @param type Provider-specific tool call type.
+   * @returns This builder for chaining.
    */
-  thinking(e) {
-    return this._thinking = e, this;
+  type(e) {
+    return this._type = e, this;
+  }
+  /**
+   * Assign the provider tool call identifier for correlation.
+   * @param id Unique identifier returned by the model.
+   * @returns This builder for chaining.
+   */
+  id(e) {
+    return e != null && (this._id = e), this;
   }
   /**
-   * Build the ModelResponse from the collected fields.
+   * Build the ToolCall with collected data, defaulting sequence to 0.
+   * @returns ToolCall instance ready to attach to a message.
    */
   build() {
-    return new M(this._toolCalls, this._role, this._content, this._thinking);
+    return this._sequence == null && (this._sequence = 0), this._id == null && (this._id = (Math.random() + 1).toString(36).slice(2, 7)), new v(
+      this._sequence,
+      this._name,
+      this._parameters,
+      this._type,
+      this._id
+    );
   }
 }
-class u extends Error {
+class I extends Error {
   constructor(e) {
-    super(e), this.name = "ModelNotImplementedError";
+    super(e), this.name = "ToolNotFoundError";
   }
 }
-class S {
+class O {
   name;
-  system_prompt;
+  systemPrompt;
   tools;
   model;
   conversation;
   conversationManager;
   toolNameToIndexMap;
+  callback;
+  constructor(e, t, o, s, i) {
+    this.name = e, this.model = o, this.conversationManager = s, this.tools = t, this.callback = i, this.conversationManager.configure(o);
+  }
+  /**
+   * Run the full agent loop for a user query: seed the conversation, invoke the model,
+   * and execute any returned tool calls until completion.
+   * @param query User-provided input to hand to the agent.
+   */
   async invoke(e) {
-    this.conversation == null && (this.conversation = new w(), this.conversationManager != null && (this.conversation.manager = this.conversationManager), this.conversation.append(
-      a.builder().role("system").content(this.system_prompt).build()
+    this.conversation == null && (this.conversation = new b(), this.conversationManager != null && (this.conversation.manager = this.conversationManager), this.systemPrompt != null && this.conversation.append(
+      h.builder().role("system").content(this.systemPrompt).build()
     )), this.conversation.append(
-      a.builder().role("user").content(e).build()
+      h.builder().role("user").content(e).build()
     );
-    let s = !1;
-    for (; !s; ) {
-      let t = await this._runQuery();
-      if (this.conversation.append(
-        a.builder().role(t.role ?? "assistant").content(t.content ?? "").thinking(t.thinking ?? "").build()
-      ), console.log("Assistant thinking: " + t.thinking), console.log("Assistant reply: " + t.content), s = !0, t.toolCalls != null && t.toolCalls.length != 0) {
-        s = !1, t.toolCalls.sort(
-          (o, i) => (o.sequence ?? 0) < (i.sequence ?? 0) ? -1 : 1
-        );
-        for (let o in t.toolCalls)
-          this._runTool(t.toolCalls[o]);
+    let t = !1;
+    for (; !t; ) {
+      let o = await this._runQuery();
+      this.callback(o), this.conversation.append(o), t = !0;
+      const s = o.filter(
+        l.ToolCall
+      );
+      if (s != null && s.length != 0) {
+        t = !1, s.sort((i, a) => (i.sequence ?? 0) < (a.sequence ?? 0) ? -1 : 1);
+        for (let i of s)
+          await this._runTool(i);
       }
     }
   }
+  /**
+   * Ask the backing model for the next response given the current conversation state.
+   * @returns Parsed model response including content, thinking, and tool calls.
+   */
   async _runQuery() {
     return await this.model.invoke(
-      new d().messages(this.conversation?.messages).tools(this.tools).build()
+      new _().messages(this.conversation?.messages).tools(this.tools).build()
     );
   }
+  /**
+   * Execute a single tool call and append the result (or error) back to the conversation.
+   * @param toolCall Tool invocation details returned by the model.
+   * @returns Tool execution output, if any.
+   */
   async _runTool(e) {
-    if (console.log("Calling tool: " + JSON.stringify(e)), this.generateToolNameToIndexMap(), !(e.name in this.toolNameToIndexMap)) {
+    if (this.generateToolNameToIndexMap(), !(e.name in this.toolNameToIndexMap)) {
       this.conversation.append(
-        a.builder().role("tool").toolName(e.name).content(JSON.stringify({ error: "tool does not exist" })).build()
+        h.builder().role("tool").toolResult(
+          m.of(
+            e,
+            new I(
+              "Agent does not have a tool with this name."
+            )
+          )
+        ).build()
       );
       return;
     }
-    let s = this.tools[this.toolNameToIndexMap[e.name]];
+    let t = this.tools[this.toolNameToIndexMap[e.name]];
     try {
-      let t = s.execute(e.parameters);
+      let o = await t.execute(e.parameters);
       this.conversation.append(
-        a.builder().role("tool").toolName(e.name).content(JSON.stringify(t)).build()
+        h.builder().role("tool").toolResult(m.of(e, o)).build()
       );
-    } catch (t) {
+    } catch (o) {
       this.conversation.append(
-        a.builder().role("tool").toolName(e.name).content(JSON.stringify(t)).build()
+        h.builder().role("tool").toolResult(m.of(e, JSON.stringify(o))).build()
       );
     }
   }
+  /**
+   * Build a lookup from tool name to index for efficient resolution of tool calls.
+   */
   generateToolNameToIndexMap() {
     if (this.toolNameToIndexMap == null) {
       this.toolNameToIndexMap = {};
@@ -245,67 +522,106 @@ class S {
         this.toolNameToIndexMap[this.tools[e].getName()] = e;
     }
   }
+  static builder() {
+    return new S();
+  }
 }
-class c extends Error {
+class S {
+  _name;
+  _systemPrompt;
+  _tools;
+  _model;
+  _conversation;
+  _conversationManager = new f();
+  _toolNameToIndexMap;
+  _callback = (e) => j(e);
+  name(e) {
+    return this._name = e, this;
+  }
+  systemPrompt(e) {
+    return this._systemPrompt = e, this;
+  }
+  tools(e) {
+    return this._tools = e, this;
+  }
+  addTool(e) {
+    return this._tools == null && (this._tools = []), this._tools.push(e), this;
+  }
+  model(e) {
+    return this._model = e, this;
+  }
+  conversationManager(e) {
+    return this._conversationManager = e, this;
+  }
+  callback(e) {
+    return this._callback = e, this;
+  }
+  build() {
+    let e = new O(
+      this._name,
+      this._tools,
+      this._model,
+      this._conversationManager,
+      this._callback
+    );
+    return this._conversation != null && (e.conversation = this._conversation), this._systemPrompt != null && (e.systemPrompt = this._systemPrompt), e;
+  }
+}
+function j(n) {
+  for (const e of n.filter(l.Thinking))
+    console.log("\x1B[90m" + e.get() + "\x1B[0m");
+  for (const e of n.filter(l.Content))
+    console.log(e.get());
+  for (const e of n.filter(l.ToolCall))
+    console.log("\x1B[32mCalling Tool: " + e.name + "\x1B[0m");
+}
+class d extends Error {
   constructor(e) {
     super(e), this.name = "ToolNotDefinedError";
   }
 }
-class j {
+class F {
   name;
   description;
   tool_schema;
+  /**
+   * Initialize tool metadata from subclass implementations.
+   */
   constructor() {
     this.name = this.getName(), this.description = this.getDescription(), this.tool_schema = this.getToolSchema();
   }
+  /**
+   * Name that uniquely identifies this tool.
+   * @returns A short, stable identifier string.
+   */
   getName() {
-    throw new c("Tool name not defined.");
+    throw new d("Tool name not defined.");
   }
+  /**
+   * Human-readable description of what the tool does.
+   * @returns Description string shown to the model.
+   */
   getDescription() {
-    throw new c("Tool description not defined.");
+    throw new d("Tool description not defined.");
   }
+  /**
+   * Structured schema describing tool parameters and output.
+   * @returns ToolSchema instance.
+   */
   getToolSchema() {
-    throw new c("Tool parameter schema not defined.");
+    throw new d("Tool parameter schema not defined.");
   }
   // @ts-ignore
+  /**
+   * Execute the tool against provided input parameters.
+   * @param input Parsed arguments from the model.
+   * @returns Tool-specific output.
+   */
   execute(e) {
     return null;
   }
 }
-class _ {
-  sequence;
-  name;
-  parameters;
-  type;
-  constructor(e, s, t, o) {
-    this.sequence = e, this.name = s, this.parameters = t, this.type = o;
-  }
-  static builder() {
-    return new k();
-  }
-}
-class k {
-  _sequence;
-  _name;
-  _parameters;
-  _type;
-  sequence(e) {
-    return this._sequence = e, this;
-  }
-  name(e) {
-    return this._name = e, this;
-  }
-  parameters(e) {
-    return this._parameters = e, this;
-  }
-  type(e) {
-    return this._type = e, this;
-  }
-  build() {
-    return this._sequence == null && (this._sequence = 0), new _(this._sequence, this._name, this._parameters, this._type);
-  }
-}
-class q {
+class B {
   parameters;
   output;
   /**
@@ -313,23 +629,24 @@ class q {
    * @param parameters Ordered list of input parameters the tool accepts.
    * @param output Human-readable description of the tool output.
    */
-  constructor(e, s) {
-    this.parameters = e, this.output = s;
+  constructor(e, t) {
+    this.parameters = e, this.output = t;
   }
   /**
    * Return a tool schema builder, so you can properly construct tools instead of dealing with the constructor
    * @returns a tool schema builder.
    */
   static builder() {
-    return new x();
+    return new D();
   }
 }
-class x {
+class D {
   _parameters;
   _output;
   /**
    * Add a parameter definition to the schema.
    * @param parameter Fully constructed parameter to append.
+   * @returns This builder for chaining.
    */
   addParameter(e) {
     return this._parameters == null && (this._parameters = []), this._parameters.push(e), this;
@@ -337,18 +654,20 @@ class x {
   /**
    * Describe the output of the tool.
    * @param output Text description of what the tool returns.
+   * @returns This builder for chaining.
    */
   output(e) {
     return this._output = e, this;
   }
   /**
    * Build the ToolSchema instance from the collected fields.
+   * @returns Constructed ToolSchema describing parameters and output.
    */
   build() {
-    return this._parameters == null && (this._parameters = []), new q(this._parameters, this._output);
+    return this._parameters == null && (this._parameters = []), new B(this._parameters, this._output);
   }
 }
-class O {
+class J {
   name;
   description;
   type;
@@ -360,55 +679,69 @@ class O {
    * @param type JSON-serializable type name (e.g., string, number).
    * @param required Whether the parameter must be provided.
    */
-  constructor(e, s, t, o) {
-    this.name = e, this.description = s, this.type = t, this.required = o, this.assertValidType();
+  constructor(e, t, o, s) {
+    this.name = e, this.description = t, this.type = o, this.required = s, this.assertValidType();
   }
   /**
    * Placeholder for validating supported parameter types.
    */
   assertValidType() {
   }
+  /**
+   * Create a builder for constructing a Parameter.
+   * @returns A ParameterBuilder instance.
+   */
   static builder() {
-    return new I();
+    return new A();
   }
 }
-class I {
+class A {
   _name;
   _description;
   _type;
   _required;
   /**
    * Set the parameter name.
+   * @returns This builder for chaining.
    */
   name(e) {
     return this._name = e, this;
   }
   /**
    * Set the parameter description.
+   * @returns This builder for chaining.
    */
   description(e) {
     return this._description = e, this;
   }
   /**
    * Set the parameter type.
+   * @returns This builder for chaining.
    */
   type(e) {
     return this._type = e, this;
   }
   /**
    * Mark the parameter as required or optional.
+   * @returns This builder for chaining.
    */
   required(e) {
     return this._required = e, this;
   }
   /**
    * Build a Parameter instance using the accumulated fields.
+   * @returns Constructed Parameter definition.
    */
   build() {
-    return this._required == null && (this._required = !1), new O(this._name, this._description, this._type, this._required);
+    return this._required == null && (this._required = !1), new J(
+      this._name,
+      this._description,
+      this._type,
+      this._required
+    );
   }
 }
-class E extends N {
+class L extends q {
   endpoint;
   model;
   options;
@@ -418,107 +751,153 @@ class E extends N {
    * @param model Model name/tag to use for inference.
    * @param options Additional Ollama options passed through to the API.
    */
-  constructor(e, s, t) {
-    super(), this.endpoint = e, this.model = s, this.options = t;
+  constructor(e, t, o) {
+    super(), this.endpoint = e, this.model = t, this.options = o;
   }
   /**
    * 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.
    */
   async invoke(e) {
-    let s = {
+    let t = {
       model: this.model,
       messages: this._formatMessages(e),
       tools: this._formatTools(e),
       ...this.options
-    }, t = await fetch(
-      this.endpoint + "/api/chat",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(s)
-      }
-    );
-    if (!t.ok)
-      throw new Error(`HTTP error! status: ${t.status}`);
-    let o = await t.json(), i = [];
-    if (o.message.tool_calls)
-      for (let h in o.message.tool_calls) {
-        const r = o.message.tool_calls[h];
-        let l = "function", g = r[l]?.name, f = r[l]?.index, y = r[l]?.arguments;
+    }, o = await fetch(this.endpoint + "/api/chat", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(t)
+    });
+    if (!o.ok)
+      throw new Error(`HTTP error! status: ${o.status}`);
+    let s = await o.json(), i = [];
+    if (s.message.tool_calls)
+      for (let a in s.message.tool_calls) {
+        const r = s.message.tool_calls[a];
+        let c = "function", T = r[c]?.name, y = r[c]?.index, w = r.id ?? void 0, M = typeof r[c]?.arguments == "string" ? JSON.parse(r[c]?.arguments) : r[c]?.arguments;
         i.push(
-          _.builder().name(g).type(l).parameters(y).sequence(f).build()
+          v.builder().name(T).type(c).parameters(M).sequence(y).id(w).build()
         );
       }
-    return new p().toolCalls(i).role(o.message.role).content(o.message.content).thinking(o.message.thinking).build();
+    return h.builder().toolCalls(i).role(s.message.role).content(s.message.content).thinking(s.message.thinking).build();
   }
   /**
    * Convert internal tool definitions into the JSON schema format expected by Ollama.
+   * @param request Model request containing declared tools.
+   * @returns Array of tool schema objects formatted for the Ollama API.
    */
   _formatTools(e) {
-    let s = [], t = [];
+    let t = [];
     for (let o of e.tools) {
-      let i = {};
+      let s = {}, i = [];
       for (let r of o.getToolSchema().parameters)
-        i[r.name] = {}, i[r.name].type = r.name, i[r.name].description = r.description, r.required && t.push(r.name);
-      let h = {
+        s[r.name] = {}, s[r.name].type = r.type, s[r.name].description = r.description, r.required && i.push(r.name);
+      let a = {
         type: "function",
         function: {
           name: o.getName(),
           description: o.getDescription(),
           parameters: {
             type: "object",
-            properties: i,
-            required: t
+            properties: s,
+            required: i
           }
         }
       };
-      s.push(h);
+      t.push(a);
     }
-    return s;
+    return t;
   }
   /**
    * Convert internal message objects into Ollama's chat message shape.
    * Passes through assistant/system/user roles and maps tool role into the expected structure.
+   * @param request Model request containing the message history.
+   * @returns Array of serialized messages ready for Ollama.
    */
   _formatMessages(e) {
-    let s = [];
-    for (let t of e.messages) {
-      if (t.role == "assistant" || t.role == "system" || t.role == "user") {
-        s.push(t);
+    let t = [];
+    for (let o of e.messages) {
+      if (o.role == "assistant" || o.role == "system" || o.role == "user") {
+        t.push(this._formatSingleMessage(o));
         continue;
       }
-      t.role == "tool" && s.push(
-        {
-          role: "tool",
-          content: t.content,
-          tool_name: t.toolName
-        }
-      );
+      if (o.role == "tool") {
+        for (const s of o.content)
+          if (s.getMessageComponentType() == l.ToolResult) {
+            const i = s;
+            t.push({
+              role: o.role,
+              name: i.toolName,
+              content: JSON.stringify(i.toolResult)
+            });
+          }
+      }
     }
-    return s;
+    return t;
+  }
+  /**
+   * Format everything sent by a user or LLM (no tools)
+   * @param message Message to serialize for Ollama.
+   * @returns Serialized message payload.
+   */
+  _formatSingleMessage(e) {
+    let t = {
+      role: e.role
+    }, o, s, i;
+    for (const a of e.content) {
+      if (a.getMessageComponentType() == l.Content) {
+        const r = a;
+        o == null && (o = ""), o += r.get();
+      }
+      if (a.getMessageComponentType() == l.Thinking) {
+        const r = a;
+        i == null && (i = ""), i += r.get();
+      }
+      if (a.getMessageComponentType() == l.ToolCall) {
+        const r = a;
+        s == null && (s = []), s.push(this._formatToolCall(r));
+      }
+    }
+    return o != null && (t.content = o), s != null && (t.tool_calls = s), i != null && (t.thinking = i), t;
+  }
+  /**
+   * Convert a ToolCall into the structure Ollama expects.
+   * @param toolCall ToolCall to serialize.
+   * @returns Minimal representation containing function name and arguments.
+   */
+  _formatToolCall(e) {
+    return {
+      function: {
+        name: e.name,
+        arguments: e.parameters
+      }
+    };
   }
 }
 export {
-  S as Agent,
-  w as Conversation,
-  v as ConversationManager,
-  T as DefaultConversationManager,
-  a as Message,
-  b as MessageBuilder,
-  N as Model,
-  C as ModelRequest,
-  d as ModelRequestBuilder,
-  M as ModelResponse,
-  p as ModelResponseBuilder,
-  E as OllamaModel,
-  O as Parameter,
-  I as ParameterBuilder,
-  j as Tool,
-  _ as ToolCall,
-  k as ToolCallBuilder,
-  q as ToolSchema,
-  x as ToolSchemaBuilder
+  O as Agent,
+  x as Content,
+  b as Conversation,
+  C as ConversationManager,
+  f as DefaultConversationManager,
+  h as Message,
+  N as MessageBuilder,
+  u as MessageComponent,
+  l as MessageComponentType,
+  q as Model,
+  E as ModelRequest,
+  _ as ModelRequestBuilder,
+  L as OllamaModel,
+  J as Parameter,
+  A as ParameterBuilder,
+  k as Thinking,
+  F as Tool,
+  v as ToolCall,
+  P as ToolCallBuilder,
+  m as ToolResult,
+  B as ToolSchema,
+  D as ToolSchemaBuilder
 };