@honeagents/hone 0.1.0 → 0.1.1

package/README.md

@@ -42,6 +42,7 @@ console.log(agent.temperature);
 ## Features
 
 - **Agent Management**: Define and fetch agent configurations with system prompts and hyperparameters
+- **Zero-Friction Tracking**: Track conversations by passing native provider formats directly - no conversion needed
 - **Tool Definitions**: Manage tool/function descriptions for function calling
 - **Text Prompts**: Reusable text templates that can be nested in agents or tools
 - **Parameter Substitution**: Dynamic prompt templates with `{{variable}}` syntax
@@ -126,11 +127,12 @@ const prompt = await hone.prompt("tone-guidelines", {
 console.log(prompt.text); // "Always be friendly and professional."
 ```
 
-### `hone.track(id, messages, options)`
+### `hone.track(id, input, options)`
 
-Track a conversation for analysis.
+Track a conversation for analysis. Accepts either normalized messages or **provider-specific formats** for zero-friction tracking.
 
 ```typescript
+// Normalized format (works with any provider)
 await hone.track(
   "conversation-123",
   [
@@ -141,6 +143,8 @@ await hone.track(
 );
 ```
 
+See [Zero-Friction Tracking](#zero-friction-tracking) for provider-specific examples.
+
 ## Nesting Entities
 
 You can compose complex prompts by nesting tools and prompts within agents:
@@ -170,6 +174,183 @@ You have access to these tools:
 });
 ```
 
+## Zero-Friction Tracking
+
+The SDK supports **zero-friction tracking** - pass your messages and responses in the provider's native format without any conversion. The SDK normalizes everything internally.
+
+### Why Zero-Friction?
+
+Different LLM providers have different message formats:
+- **OpenAI**: Messages with `role` and `content`, tool calls in `tool_calls` array
+- **Anthropic**: Separate `system` parameter, content blocks instead of strings
+- **Gemini**: Uses `contents` with `parts`, roles are `user`/`model`
+
+Instead of manually converting between formats, just pass what you already have.
+
+### OpenAI
+
+```typescript
+import OpenAI from "openai";
+import { Hone } from "@honeagents/hone";
+
+const openai = new OpenAI();
+const hone = new Hone({ apiKey: process.env.HONE_API_KEY! });
+
+// Your messages in OpenAI's native format
+const messages: OpenAI.ChatCompletionMessageParam[] = [
+  { role: "system", content: "You are a helpful assistant." },
+  { role: "user", content: "What's the capital of France?" },
+];
+
+// Make the API call
+const response = await openai.chat.completions.create({
+  model: "gpt-4o",
+  messages,
+});
+
+// Zero-friction tracking - just pass what you have!
+await hone.track(
+  "my-conversation",
+  {
+    provider: "openai",
+    messages,  // Your OpenAI messages array
+    response,  // The raw ChatCompletion response
+  },
+  { sessionId: "session-123" }
+);
+```
+
+### Anthropic
+
+```typescript
+import Anthropic from "@anthropic-ai/sdk";
+import { Hone } from "@honeagents/hone";
+
+const anthropic = new Anthropic();
+const hone = new Hone({ apiKey: process.env.HONE_API_KEY! });
+
+// Anthropic has system prompt separate from messages
+const systemPrompt = "You are a helpful assistant.";
+const messages: Anthropic.MessageParam[] = [
+  { role: "user", content: "What's the capital of Japan?" },
+];
+
+// Make the API call
+const response = await anthropic.messages.create({
+  model: "claude-sonnet-4-20250514",
+  system: systemPrompt,
+  messages,
+  max_tokens: 1024,
+});
+
+// Zero-friction tracking - include the system prompt
+await hone.track(
+  "my-conversation",
+  {
+    provider: "anthropic",
+    messages,       // Your Anthropic messages array
+    system: systemPrompt,  // Anthropic's separate system prompt
+    response,       // The raw Message response
+  },
+  { sessionId: "session-123" }
+);
+```
+
+### Google Gemini
+
+```typescript
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { Hone } from "@honeagents/hone";
+
+const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY!);
+const hone = new Hone({ apiKey: process.env.HONE_API_KEY! });
+
+// Gemini uses "contents" with "parts"
+const systemInstruction = "You are a helpful assistant.";
+const model = genAI.getGenerativeModel({
+  model: "gemini-1.5-flash",
+  systemInstruction,
+});
+
+const contents = [
+  { role: "user" as const, parts: [{ text: "What's the capital of Brazil?" }] },
+];
+
+// Make the API call
+const response = await model.generateContent({ contents });
+
+// Zero-friction tracking
+await hone.track(
+  "my-conversation",
+  {
+    provider: "gemini",
+    contents,              // Your Gemini contents array
+    systemInstruction,     // Gemini's system instruction
+    response,              // The raw GenerateContentResult
+  },
+  { sessionId: "session-123" }
+);
+```
+
+### Multi-Turn Conversations
+
+For multi-turn conversations, just keep adding to your messages array and track after each turn:
+
+```typescript
+// OpenAI example
+const messages: OpenAI.ChatCompletionMessageParam[] = [
+  { role: "system", content: agent.systemPrompt },
+  { role: "user", content: "Hello!" },
+];
+
+// First turn
+const response1 = await openai.chat.completions.create({ model: "gpt-4o", messages });
+await hone.track("convo", { provider: "openai", messages, response: response1 }, { sessionId });
+
+// Add assistant response and user follow-up
+messages.push({ role: "assistant", content: response1.choices[0].message.content ?? "" });
+messages.push({ role: "user", content: "Tell me more!" });
+
+// Second turn
+const response2 = await openai.chat.completions.create({ model: "gpt-4o", messages });
+await hone.track("convo", { provider: "openai", messages, response: response2 }, { sessionId });
+```
+
+### With Tool Calls
+
+Tool calls are automatically extracted and normalized:
+
+```typescript
+// OpenAI with tools
+const response = await openai.chat.completions.create({
+  model: "gpt-4o",
+  messages,
+  tools: [{ type: "function", function: { name: "get_weather", ... } }],
+});
+
+// If the model made tool calls, they're automatically extracted
+await hone.track("convo", { provider: "openai", messages, response }, { sessionId });
+
+// After executing the tool, add the result and continue
+messages.push(response.choices[0].message); // Contains tool_calls
+messages.push({
+  role: "tool",
+  tool_call_id: response.choices[0].message.tool_calls![0].id,
+  content: JSON.stringify({ temperature: 72 }),
+});
+
+const response2 = await openai.chat.completions.create({ model: "gpt-4o", messages });
+await hone.track("convo", { provider: "openai", messages, response: response2 }, { sessionId });
+```
+
+### Supported Formats Summary
+
+| Provider | Input Type | System Prompt | Response Type |
+|----------|------------|---------------|---------------|
+| OpenAI | `ChatCompletionMessageParam[]` | In messages array | `ChatCompletion` |
+| Anthropic | `MessageParam[]` | Separate `system` param | `Message` |
+| Gemini | `Content[]` | Separate `systemInstruction` | `GenerateContentResult` |
+
 ## Provider Constants
 
 Use type-safe provider constants:
@@ -267,16 +448,34 @@ The SDK is written in TypeScript and provides comprehensive type definitions:
 
 ```typescript
 import type {
+  // Client types
   HoneClient,
   HoneConfig,
+
+  // Agent types
   AgentResult,
-  ToolResult,
-  TextPromptResult,
   GetAgentOptions,
+
+  // Tool types
+  ToolResult,
   GetToolOptions,
+
+  // Prompt types
+  TextPromptResult,
   GetTextPromptOptions,
+
+  // Message types
   Message,
   ToolCall,
+
+  // Tracking types (zero-friction)
+  TrackInput,
+  TrackOpenAIInput,
+  TrackAnthropicInput,
+  TrackGeminiInput,
+  TrackConversationOptions,
+
+  // Provider types
   AIProviderValue,
 } from "@honeagents/hone";
 ```

package/dist/index.d.mts

@@ -1,3 +1,7 @@
+import { ChatCompletionMessageParam, ChatCompletion } from 'openai/resources/chat/completions';
+import { MessageParam, Message as Message$1 } from '@anthropic-ai/sdk/resources/messages';
+import { Content, GenerateContentResult } from '@google/generative-ai';
+
 /**
  * AI Provider definitions compatible with Vercel AI SDK.
  *
@@ -336,7 +340,54 @@ type Message = {
 type TrackConversationOptions = {
     sessionId: string;
 };
-type HoneTrack = (id: string, messages: Message[], options: TrackConversationOptions) => Promise<void>;
+type HoneTrack = (id: string, input: TrackInput, options: TrackConversationOptions) => Promise<void>;
+/**
+ * Track input for OpenAI conversations.
+ * Pass your messages and response exactly as-is from the OpenAI SDK.
+ */
+type TrackOpenAIInput = {
+    provider: "openai";
+    messages: ChatCompletionMessageParam[];
+    response: ChatCompletion;
+};
+/**
+ * Track input for Anthropic conversations.
+ * Pass your messages, system prompt, and response exactly as-is from the Anthropic SDK.
+ */
+type TrackAnthropicInput = {
+    provider: "anthropic";
+    messages: MessageParam[];
+    system?: string;
+    response: Message$1;
+};
+/**
+ * Track input for Gemini conversations.
+ * Pass your contents, system instruction, and response exactly as-is from the Gemini SDK.
+ */
+type TrackGeminiInput = {
+    provider: "gemini";
+    contents: Content[];
+    systemInstruction?: string;
+    response: GenerateContentResult;
+};
+/**
+ * Union type for all track inputs.
+ * Accepts either the normalized Message[] format or provider-specific formats.
+ *
+ * @example
+ * // OpenAI - just pass what you have
+ * await hone.track("convo", { provider: "openai", messages, response }, { sessionId })
+ *
+ * // Anthropic
+ * await hone.track("convo", { provider: "anthropic", messages, system, response }, { sessionId })
+ *
+ * // Gemini
+ * await hone.track("convo", { provider: "gemini", contents, systemInstruction, response }, { sessionId })
+ *
+ * // Or use the normalized format directly
+ * await hone.track("convo", normalizedMessages, { sessionId })
+ */
+type TrackInput = Message[] | TrackOpenAIInput | TrackAnthropicInput | TrackGeminiInput;
 type HoneClient = {
     /**
      * Fetches and evaluates an agent by its ID with the given options.
@@ -360,10 +411,25 @@ type HoneClient = {
      */
     prompt: HoneTextPrompt;
     /**
-     * Adds messages to track a conversation under the given ID.
+     * Tracks a conversation under the given ID.
+     * Accepts either normalized Message[] or provider-specific formats for zero-friction tracking.
+     *
      * @param id The unique identifier for the conversation to track.
-     * @param messages An array of Message objects representing the conversation.
-     * @param options Optional TrackConversationOptions such as sessionId.
+     * @param input Either a Message[] array or a provider-specific input object.
+     * @param options TrackConversationOptions including sessionId.
+     *
+     * @example
+     * // OpenAI - just pass your messages and response
+     * await hone.track("convo", { provider: "openai", messages, response }, { sessionId })
+     *
+     * // Anthropic - include system prompt
+     * await hone.track("convo", { provider: "anthropic", messages, system, response }, { sessionId })
+     *
+     * // Gemini - use contents and systemInstruction
+     * await hone.track("convo", { provider: "gemini", contents, systemInstruction, response }, { sessionId })
+     *
+     * // Or use normalized format directly
+     * await hone.track("convo", normalizedMessages, { sessionId })
      */
     track: HoneTrack;
 };
@@ -428,7 +494,7 @@ declare class Hone implements HoneClient {
     agent<TExtra extends Record<string, unknown> = Record<string, unknown>>(id: string, options: GetAgentOptions<TExtra>): Promise<AgentResult<TExtra>>;
     tool(id: string, options: GetToolOptions): Promise<ToolResult>;
     prompt(id: string, options: GetTextPromptOptions): Promise<TextPromptResult>;
-    track(id: string, messages: Message[], options: TrackConversationOptions): Promise<void>;
+    track(id: string, input: TrackInput, options: TrackConversationOptions): Promise<void>;
 }
 declare function createHoneClient(config: HoneConfig): HoneClient;
 
@@ -492,21 +558,7 @@ declare function createToolResultMessage(toolCallId: string, result: unknown): M
  * await hone.track("conversation", [...existingMessages, ...messages], { sessionId });
  * ```
  */
-declare function extractOpenAIMessages(response: {
-    choices: Array<{
-        message: {
-            role: string;
-            content: string | null;
-            tool_calls?: Array<{
-                id: string;
-                function: {
-                    name: string;
-                    arguments: string;
-                };
-            }>;
-        };
-    }>;
-}): Message[];
+declare function extractOpenAIMessages(response: ChatCompletion): Message[];
 /**
  * Extracts messages from an Anthropic Claude response.
  *
@@ -530,18 +582,7 @@ declare function extractOpenAIMessages(response: {
  * await hone.track("conversation", [...existingMessages, ...messages], { sessionId });
  * ```
  */
-declare function extractAnthropicMessages(response: {
-    role: string;
-    content: Array<{
-        type: "text";
-        text: string;
-    } | {
-        type: "tool_use";
-        id: string;
-        name: string;
-        input: unknown;
-    }>;
-}): Message[];
+declare function extractAnthropicMessages(response: Message$1): Message[];
 /**
  * Extracts messages from a Google Gemini response.
  *
@@ -568,21 +609,31 @@ declare function extractAnthropicMessages(response: {
  * await hone.track("conversation", [...existingMessages, ...messages], { sessionId });
  * ```
  */
-declare function extractGeminiMessages(response: {
-    candidates?: Array<{
-        content?: {
-            role?: string;
-            parts?: Array<{
-                text: string;
-            } | {
-                functionCall: {
-                    name: string;
-                    args: Record<string, unknown>;
-                };
-            }>;
-        };
-    }>;
-}): Message[];
+declare function extractGeminiMessages(response: GenerateContentResult): Message[];
+
+/**
+ * Normalizes OpenAI input messages to Hone's Message format.
+ *
+ * @param messages - Array of OpenAI ChatCompletionMessageParam
+ * @returns Array of normalized Message objects
+ */
+declare function normalizeOpenAIMessages(messages: ChatCompletionMessageParam[]): Message[];
+/**
+ * Normalizes Anthropic input messages to Hone's Message format.
+ * Note: System prompt should be passed separately to track().
+ *
+ * @param messages - Array of Anthropic MessageParam
+ * @returns Array of normalized Message objects
+ */
+declare function normalizeAnthropicMessages(messages: MessageParam[]): Message[];
+/**
+ * Normalizes Gemini input contents to Hone's Message format.
+ * Note: System instruction should be passed separately to track().
+ *
+ * @param contents - Array of Gemini Content
+ * @returns Array of normalized Message objects
+ */
+declare function normalizeGeminiContents(contents: Content[]): Message[];
 /**
  * Short alias for createToolResultMessage.
  * Creates a tool result message responding to a specific tool call.
@@ -671,4 +722,4 @@ declare const formatPromptRequest: typeof formatAgentRequest;
 /** @deprecated Use updateAgentNodes instead */
 declare const updatePromptNodes: typeof updateAgentNodes;
 
-export { AIProvider, type AIProviderValue, AI_PROVIDER_VALUES, type AgentNode, type AgentRequest, type AgentResponse, type AgentResponseItem, type AgentResult, type GetAgentOptions, type GetPromptOptions, Hone, type HoneAgent, type HoneClient, type HonePrompt, type HoneTrack, type Hyperparameters, type Message, type PromptNode, type PromptRequest, type PromptResponse, type ToolCall, createHoneClient, createToolCallMessage, createToolResultMessage, evaluateAgent, evaluatePrompt, extractAnthropicMessages, extractGeminiMessages, extractOpenAIMessages, formatAgentRequest, formatPromptRequest, fromAnthropic, fromGemini, fromOpenAI, getAgentNode, getPromptNode, getProviderDisplayName, insertParamsIntoPrompt, isValidProvider, toolResult, traverseAgentNode, traversePromptNode, updateAgentNodes, updatePromptNodes };
+export { AIProvider, type AIProviderValue, AI_PROVIDER_VALUES, type AgentNode, type AgentRequest, type AgentResponse, type AgentResponseItem, type AgentResult, type GetAgentOptions, type GetPromptOptions, Hone, type HoneAgent, type HoneClient, type HonePrompt, type HoneTrack, type Hyperparameters, type Message, type PromptNode, type PromptRequest, type PromptResponse, type ToolCall, type TrackAnthropicInput, type TrackConversationOptions, type TrackGeminiInput, type TrackInput, type TrackOpenAIInput, createHoneClient, createToolCallMessage, createToolResultMessage, evaluateAgent, evaluatePrompt, extractAnthropicMessages, extractGeminiMessages, extractOpenAIMessages, formatAgentRequest, formatPromptRequest, fromAnthropic, fromGemini, fromOpenAI, getAgentNode, getPromptNode, getProviderDisplayName, insertParamsIntoPrompt, isValidProvider, normalizeAnthropicMessages, normalizeGeminiContents, normalizeOpenAIMessages, toolResult, traverseAgentNode, traversePromptNode, updateAgentNodes, updatePromptNodes };

package/dist/index.d.ts

@@ -1,3 +1,7 @@
+import { ChatCompletionMessageParam, ChatCompletion } from 'openai/resources/chat/completions';
+import { MessageParam, Message as Message$1 } from '@anthropic-ai/sdk/resources/messages';
+import { Content, GenerateContentResult } from '@google/generative-ai';
+
 /**
  * AI Provider definitions compatible with Vercel AI SDK.
  *
@@ -336,7 +340,54 @@ type Message = {
 type TrackConversationOptions = {
     sessionId: string;
 };
-type HoneTrack = (id: string, messages: Message[], options: TrackConversationOptions) => Promise<void>;
+type HoneTrack = (id: string, input: TrackInput, options: TrackConversationOptions) => Promise<void>;
+/**
+ * Track input for OpenAI conversations.
+ * Pass your messages and response exactly as-is from the OpenAI SDK.
+ */
+type TrackOpenAIInput = {
+    provider: "openai";
+    messages: ChatCompletionMessageParam[];
+    response: ChatCompletion;
+};
+/**
+ * Track input for Anthropic conversations.
+ * Pass your messages, system prompt, and response exactly as-is from the Anthropic SDK.
+ */
+type TrackAnthropicInput = {
+    provider: "anthropic";
+    messages: MessageParam[];
+    system?: string;
+    response: Message$1;
+};
+/**
+ * Track input for Gemini conversations.
+ * Pass your contents, system instruction, and response exactly as-is from the Gemini SDK.
+ */
+type TrackGeminiInput = {
+    provider: "gemini";
+    contents: Content[];
+    systemInstruction?: string;
+    response: GenerateContentResult;
+};
+/**
+ * Union type for all track inputs.
+ * Accepts either the normalized Message[] format or provider-specific formats.
+ *
+ * @example
+ * // OpenAI - just pass what you have
+ * await hone.track("convo", { provider: "openai", messages, response }, { sessionId })
+ *
+ * // Anthropic
+ * await hone.track("convo", { provider: "anthropic", messages, system, response }, { sessionId })
+ *
+ * // Gemini
+ * await hone.track("convo", { provider: "gemini", contents, systemInstruction, response }, { sessionId })
+ *
+ * // Or use the normalized format directly
+ * await hone.track("convo", normalizedMessages, { sessionId })
+ */
+type TrackInput = Message[] | TrackOpenAIInput | TrackAnthropicInput | TrackGeminiInput;
 type HoneClient = {
     /**
      * Fetches and evaluates an agent by its ID with the given options.
@@ -360,10 +411,25 @@ type HoneClient = {
      */
     prompt: HoneTextPrompt;
     /**
-     * Adds messages to track a conversation under the given ID.
+     * Tracks a conversation under the given ID.
+     * Accepts either normalized Message[] or provider-specific formats for zero-friction tracking.
+     *
      * @param id The unique identifier for the conversation to track.
-     * @param messages An array of Message objects representing the conversation.
-     * @param options Optional TrackConversationOptions such as sessionId.
+     * @param input Either a Message[] array or a provider-specific input object.
+     * @param options TrackConversationOptions including sessionId.
+     *
+     * @example
+     * // OpenAI - just pass your messages and response
+     * await hone.track("convo", { provider: "openai", messages, response }, { sessionId })
+     *
+     * // Anthropic - include system prompt
+     * await hone.track("convo", { provider: "anthropic", messages, system, response }, { sessionId })
+     *
+     * // Gemini - use contents and systemInstruction
+     * await hone.track("convo", { provider: "gemini", contents, systemInstruction, response }, { sessionId })
+     *
+     * // Or use normalized format directly
+     * await hone.track("convo", normalizedMessages, { sessionId })
      */
     track: HoneTrack;
 };
@@ -428,7 +494,7 @@ declare class Hone implements HoneClient {
     agent<TExtra extends Record<string, unknown> = Record<string, unknown>>(id: string, options: GetAgentOptions<TExtra>): Promise<AgentResult<TExtra>>;
     tool(id: string, options: GetToolOptions): Promise<ToolResult>;
     prompt(id: string, options: GetTextPromptOptions): Promise<TextPromptResult>;
-    track(id: string, messages: Message[], options: TrackConversationOptions): Promise<void>;
+    track(id: string, input: TrackInput, options: TrackConversationOptions): Promise<void>;
 }
 declare function createHoneClient(config: HoneConfig): HoneClient;
 
@@ -492,21 +558,7 @@ declare function createToolResultMessage(toolCallId: string, result: unknown): M
  * await hone.track("conversation", [...existingMessages, ...messages], { sessionId });
  * ```
  */
-declare function extractOpenAIMessages(response: {
-    choices: Array<{
-        message: {
-            role: string;
-            content: string | null;
-            tool_calls?: Array<{
-                id: string;
-                function: {
-                    name: string;
-                    arguments: string;
-                };
-            }>;
-        };
-    }>;
-}): Message[];
+declare function extractOpenAIMessages(response: ChatCompletion): Message[];
 /**
  * Extracts messages from an Anthropic Claude response.
  *
@@ -530,18 +582,7 @@ declare function extractOpenAIMessages(response: {
  * await hone.track("conversation", [...existingMessages, ...messages], { sessionId });
  * ```
  */
-declare function extractAnthropicMessages(response: {
-    role: string;
-    content: Array<{
-        type: "text";
-        text: string;
-    } | {
-        type: "tool_use";
-        id: string;
-        name: string;
-        input: unknown;
-    }>;
-}): Message[];
+declare function extractAnthropicMessages(response: Message$1): Message[];
 /**
  * Extracts messages from a Google Gemini response.
  *
@@ -568,21 +609,31 @@ declare function extractAnthropicMessages(response: {
  * await hone.track("conversation", [...existingMessages, ...messages], { sessionId });
  * ```
  */
-declare function extractGeminiMessages(response: {
-    candidates?: Array<{
-        content?: {
-            role?: string;
-            parts?: Array<{
-                text: string;
-            } | {
-                functionCall: {
-                    name: string;
-                    args: Record<string, unknown>;
-                };
-            }>;
-        };
-    }>;
-}): Message[];
+declare function extractGeminiMessages(response: GenerateContentResult): Message[];
+
+/**
+ * Normalizes OpenAI input messages to Hone's Message format.
+ *
+ * @param messages - Array of OpenAI ChatCompletionMessageParam
+ * @returns Array of normalized Message objects
+ */
+declare function normalizeOpenAIMessages(messages: ChatCompletionMessageParam[]): Message[];
+/**
+ * Normalizes Anthropic input messages to Hone's Message format.
+ * Note: System prompt should be passed separately to track().
+ *
+ * @param messages - Array of Anthropic MessageParam
+ * @returns Array of normalized Message objects
+ */
+declare function normalizeAnthropicMessages(messages: MessageParam[]): Message[];
+/**
+ * Normalizes Gemini input contents to Hone's Message format.
+ * Note: System instruction should be passed separately to track().
+ *
+ * @param contents - Array of Gemini Content
+ * @returns Array of normalized Message objects
+ */
+declare function normalizeGeminiContents(contents: Content[]): Message[];
 /**
  * Short alias for createToolResultMessage.
  * Creates a tool result message responding to a specific tool call.
@@ -671,4 +722,4 @@ declare const formatPromptRequest: typeof formatAgentRequest;
 /** @deprecated Use updateAgentNodes instead */
 declare const updatePromptNodes: typeof updateAgentNodes;
 
-export { AIProvider, type AIProviderValue, AI_PROVIDER_VALUES, type AgentNode, type AgentRequest, type AgentResponse, type AgentResponseItem, type AgentResult, type GetAgentOptions, type GetPromptOptions, Hone, type HoneAgent, type HoneClient, type HonePrompt, type HoneTrack, type Hyperparameters, type Message, type PromptNode, type PromptRequest, type PromptResponse, type ToolCall, createHoneClient, createToolCallMessage, createToolResultMessage, evaluateAgent, evaluatePrompt, extractAnthropicMessages, extractGeminiMessages, extractOpenAIMessages, formatAgentRequest, formatPromptRequest, fromAnthropic, fromGemini, fromOpenAI, getAgentNode, getPromptNode, getProviderDisplayName, insertParamsIntoPrompt, isValidProvider, toolResult, traverseAgentNode, traversePromptNode, updateAgentNodes, updatePromptNodes };
+export { AIProvider, type AIProviderValue, AI_PROVIDER_VALUES, type AgentNode, type AgentRequest, type AgentResponse, type AgentResponseItem, type AgentResult, type GetAgentOptions, type GetPromptOptions, Hone, type HoneAgent, type HoneClient, type HonePrompt, type HoneTrack, type Hyperparameters, type Message, type PromptNode, type PromptRequest, type PromptResponse, type ToolCall, type TrackAnthropicInput, type TrackConversationOptions, type TrackGeminiInput, type TrackInput, type TrackOpenAIInput, createHoneClient, createToolCallMessage, createToolResultMessage, evaluateAgent, evaluatePrompt, extractAnthropicMessages, extractGeminiMessages, extractOpenAIMessages, formatAgentRequest, formatPromptRequest, fromAnthropic, fromGemini, fromOpenAI, getAgentNode, getPromptNode, getProviderDisplayName, insertParamsIntoPrompt, isValidProvider, normalizeAnthropicMessages, normalizeGeminiContents, normalizeOpenAIMessages, toolResult, traverseAgentNode, traversePromptNode, updateAgentNodes, updatePromptNodes };