@honeagents/hone 0.1.0

package/dist/index.js

@@ -0,0 +1,570 @@
+'use strict';
+
+// src/agent.ts
+function isAgentOptions(value) {
+  return typeof value === "object" && value !== null && "defaultPrompt" in value && "model" in value && "provider" in value;
+}
+function isToolOptions(value) {
+  if (typeof value !== "object" || value === null || !("defaultPrompt" in value) || "model" in value || "provider" in value) {
+    return false;
+  }
+  return "_type" in value && value._type === "tool";
+}
+function isTextPromptOptions(value) {
+  return typeof value === "object" && value !== null && "defaultPrompt" in value && !("model" in value) && !("provider" in value) && !("_type" in value && value._type === "tool");
+}
+function getAgentNode(id, options, ancestorIds = /* @__PURE__ */ new Set()) {
+  const node = getEntityNode(id, "agent", options, ancestorIds);
+  return node;
+}
+function getToolNode(id, options, ancestorIds = /* @__PURE__ */ new Set()) {
+  const node = getEntityNode(id, "tool", options, ancestorIds);
+  return node;
+}
+function getTextPromptNode(id, options, ancestorIds = /* @__PURE__ */ new Set()) {
+  const node = getEntityNode(id, "prompt", options, ancestorIds);
+  return node;
+}
+function getEntityNode(id, type, options, ancestorIds = /* @__PURE__ */ new Set()) {
+  if (options?.params && id in options.params) {
+    throw new Error(
+      `Self-referencing ${type} detected: ${type} "${id}" cannot reference itself as a parameter`
+    );
+  }
+  if (ancestorIds.has(id)) {
+    const path = Array.from(ancestorIds).concat(id).join(" -> ");
+    throw new Error(`Circular ${type} reference detected: ${path}`);
+  }
+  const children = [];
+  const newAncestorIds = new Set(ancestorIds).add(id);
+  const simpleParams = {};
+  for (const [paramId, value] of Object.entries(options?.params || {})) {
+    if (typeof value === "string") {
+      simpleParams[paramId] = value;
+    } else if (isAgentOptions(value)) {
+      children.push(getEntityNode(paramId, "agent", value, newAncestorIds));
+    } else if (isToolOptions(value)) {
+      children.push(getEntityNode(paramId, "tool", value, newAncestorIds));
+    } else if (isTextPromptOptions(value)) {
+      children.push(getEntityNode(paramId, "prompt", value, newAncestorIds));
+    }
+  }
+  const node = {
+    id,
+    type,
+    majorVersion: options.majorVersion,
+    name: options.name,
+    params: simpleParams,
+    prompt: options.defaultPrompt,
+    children
+  };
+  if (type === "agent" && isAgentOptions(options)) {
+    node.model = options.model;
+    node.provider = options.provider;
+    node.temperature = options.temperature;
+    node.maxTokens = options.maxTokens;
+    node.topP = options.topP;
+    node.frequencyPenalty = options.frequencyPenalty;
+    node.presencePenalty = options.presencePenalty;
+    node.stopSequences = options.stopSequences;
+    node.tools = options.tools;
+  }
+  return node;
+}
+function evaluateEntity(node) {
+  const evaluated = /* @__PURE__ */ new Map();
+  function evaluate(node2) {
+    if (evaluated.has(node2.id)) {
+      return evaluated.get(node2.id);
+    }
+    const params = { ...node2.params };
+    for (const child of node2.children) {
+      params[child.id] = evaluate(child);
+    }
+    validateEntityParams(node2.prompt, params, node2.id, node2.type);
+    const result = insertParamsIntoPrompt(node2.prompt, params);
+    evaluated.set(node2.id, result);
+    return result;
+  }
+  return evaluate(node);
+}
+function evaluateAgent(node) {
+  return evaluateEntity(node);
+}
+function validateEntityParams(prompt, params, nodeId, type) {
+  const placeholderRegex = /\{\{(\w+)\}\}/g;
+  const matches = prompt.matchAll(placeholderRegex);
+  const missingParams = [];
+  for (const match of matches) {
+    const paramName = match[1];
+    if (!(paramName in params)) {
+      missingParams.push(paramName);
+    }
+  }
+  if (missingParams.length > 0) {
+    const uniqueMissing = [...new Set(missingParams)];
+    throw new Error(
+      `Missing parameter${uniqueMissing.length > 1 ? "s" : ""} in ${type} "${nodeId}": ${uniqueMissing.join(", ")}`
+    );
+  }
+}
+function insertParamsIntoPrompt(prompt, params) {
+  if (!params) return prompt;
+  let result = prompt;
+  for (const [key, value] of Object.entries(params)) {
+    result = result.replace(new RegExp(`{{${key}}}`, "g"), value);
+  }
+  return result;
+}
+function traverseEntityNode(node, callback, parentId = null) {
+  callback(node, parentId);
+  for (const child of node.children) {
+    traverseEntityNode(child, callback, node.id);
+  }
+}
+function traverseAgentNode(node, callback, parentId = null) {
+  traverseEntityNode(
+    node,
+    callback,
+    parentId
+  );
+}
+function formatEntityRequest(node) {
+  function formatNode(node2) {
+    const paramKeys = [
+      ...Object.keys(node2.params),
+      ...node2.children.map((child) => child.id)
+    ];
+    return {
+      id: node2.id,
+      type: node2.type,
+      name: node2.name,
+      majorVersion: node2.majorVersion,
+      prompt: node2.prompt,
+      paramKeys,
+      childrenIds: node2.children.map((child) => child.id),
+      childrenTypes: node2.children.map((child) => child.type),
+      // Hyperparameters (only for agents)
+      model: node2.model,
+      provider: node2.provider,
+      temperature: node2.temperature,
+      maxTokens: node2.maxTokens,
+      topP: node2.topP,
+      frequencyPenalty: node2.frequencyPenalty,
+      presencePenalty: node2.presencePenalty,
+      stopSequences: node2.stopSequences,
+      tools: node2.tools
+    };
+  }
+  const map = {};
+  traverseEntityNode(node, (currentNode) => {
+    map[currentNode.id] = formatNode(currentNode);
+  });
+  return {
+    entities: {
+      rootId: node.id,
+      rootType: node.type,
+      map
+    }
+  };
+}
+function formatAgentRequest(node) {
+  function formatNode(node2) {
+    const paramKeys = [
+      ...Object.keys(node2.params),
+      ...node2.children.map((child) => child.id)
+    ];
+    return {
+      id: node2.id,
+      type: node2.type,
+      name: node2.name,
+      majorVersion: node2.majorVersion,
+      prompt: node2.prompt,
+      paramKeys,
+      childrenIds: node2.children.map((child) => child.id),
+      // Hyperparameters
+      model: node2.model,
+      provider: node2.provider,
+      temperature: node2.temperature,
+      maxTokens: node2.maxTokens,
+      topP: node2.topP,
+      frequencyPenalty: node2.frequencyPenalty,
+      presencePenalty: node2.presencePenalty,
+      stopSequences: node2.stopSequences,
+      tools: node2.tools
+    };
+  }
+  const map = {};
+  traverseAgentNode(node, (currentNode) => {
+    map[currentNode.id] = formatNode(currentNode);
+  });
+  return {
+    agents: {
+      rootId: node.id,
+      map
+    }
+  };
+}
+function updateEntityNodes(root, callback) {
+  function updateNode(node) {
+    const updatedChildren = node.children.map(updateNode);
+    const updatedNode = { ...node, children: updatedChildren };
+    return callback(updatedNode);
+  }
+  return updateNode(root);
+}
+function updateAgentNodes(root, callback) {
+  return updateEntityNodes(
+    root,
+    callback
+  );
+}
+var getPromptNode = getAgentNode;
+var evaluatePrompt = evaluateAgent;
+var traversePromptNode = traverseAgentNode;
+var formatPromptRequest = formatAgentRequest;
+var updatePromptNodes = updateAgentNodes;
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://honeagents.ai/api";
+var DEFAULT_TIMEOUT = 1e4;
+var Hone = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = process.env.HONE_API_URL || config.baseUrl || DEFAULT_BASE_URL;
+    this.timeout = config.timeout || DEFAULT_TIMEOUT;
+  }
+  async makeRequest(endpoint, method = "GET", body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const url = `${this.baseUrl}${endpoint}`;
+      console.log(`Hone API Request: ${method} ${url}`);
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "x-api-key": this.apiKey,
+          "Content-Type": "application/json",
+          "User-Agent": "hone-sdk-typescript/0.1.0"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          `Hone API error (${response.status}): ${errorData.error || errorData.message || response.statusText}`
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Hone API request timed out after ${this.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  async agent(id, options) {
+    const node = getAgentNode(id, options);
+    try {
+      const formattedRequest = formatEntityRequest(node);
+      if (options.extra) {
+        const rootEntity = formattedRequest.entities.map[id];
+        if (rootEntity) {
+          rootEntity.extra = options.extra;
+        }
+      }
+      const response = await this.makeRequest("/sync_entities", "POST", formattedRequest);
+      const entityMap = response.entities;
+      const updatedAgentNode = updateAgentNodes(node, (agentNode) => {
+        const responseItem = entityMap[agentNode.id];
+        return {
+          ...agentNode,
+          prompt: responseItem?.prompt || agentNode.prompt,
+          // Update hyperparameters from API response (if present)
+          model: responseItem?.model ?? agentNode.model,
+          temperature: responseItem?.temperature ?? agentNode.temperature,
+          maxTokens: responseItem?.maxTokens ?? agentNode.maxTokens,
+          topP: responseItem?.topP ?? agentNode.topP,
+          frequencyPenalty: responseItem?.frequencyPenalty ?? agentNode.frequencyPenalty,
+          presencePenalty: responseItem?.presencePenalty ?? agentNode.presencePenalty,
+          stopSequences: responseItem?.stopSequences ?? agentNode.stopSequences
+        };
+      });
+      const rootResponse = entityMap[id];
+      const extraFromResponse = rootResponse?.extra ?? options.extra ?? {};
+      return {
+        systemPrompt: evaluateAgent(updatedAgentNode),
+        model: rootResponse?.model ?? options.model,
+        provider: rootResponse?.provider ?? options.provider,
+        temperature: rootResponse?.temperature ?? options.temperature ?? null,
+        maxTokens: rootResponse?.maxTokens ?? options.maxTokens ?? null,
+        topP: rootResponse?.topP ?? options.topP ?? null,
+        frequencyPenalty: rootResponse?.frequencyPenalty ?? options.frequencyPenalty ?? null,
+        presencePenalty: rootResponse?.presencePenalty ?? options.presencePenalty ?? null,
+        stopSequences: rootResponse?.stopSequences ?? options.stopSequences ?? [],
+        tools: rootResponse?.tools ?? options.tools ?? [],
+        ...extraFromResponse
+      };
+    } catch (error) {
+      console.log("Error fetching agent, using fallback:", error);
+      const extraData = options.extra ?? {};
+      return {
+        systemPrompt: evaluateAgent(node),
+        model: options.model,
+        provider: options.provider,
+        temperature: options.temperature ?? null,
+        maxTokens: options.maxTokens ?? null,
+        topP: options.topP ?? null,
+        frequencyPenalty: options.frequencyPenalty ?? null,
+        presencePenalty: options.presencePenalty ?? null,
+        stopSequences: options.stopSequences ?? [],
+        tools: options.tools ?? [],
+        ...extraData
+      };
+    }
+  }
+  async tool(id, options) {
+    const node = getToolNode(id, options);
+    try {
+      const formattedRequest = formatEntityRequest(node);
+      const response = await this.makeRequest("/sync_entities", "POST", formattedRequest);
+      const entityMap = response.entities;
+      const updatedToolNode = updateEntityNodes(node, (entityNode) => {
+        const responseItem = entityMap[entityNode.id];
+        return {
+          ...entityNode,
+          prompt: responseItem?.prompt || entityNode.prompt
+        };
+      });
+      return {
+        prompt: evaluateEntity(updatedToolNode)
+      };
+    } catch (error) {
+      console.log("Error fetching tool, using fallback:", error);
+      return {
+        prompt: evaluateEntity(node)
+      };
+    }
+  }
+  async prompt(id, options) {
+    const node = getTextPromptNode(id, options);
+    try {
+      const formattedRequest = formatEntityRequest(node);
+      const response = await this.makeRequest("/sync_entities", "POST", formattedRequest);
+      const entityMap = response.entities;
+      const updatedPromptNode = updateEntityNodes(node, (entityNode) => {
+        const responseItem = entityMap[entityNode.id];
+        return {
+          ...entityNode,
+          prompt: responseItem?.prompt || entityNode.prompt
+        };
+      });
+      return {
+        text: evaluateEntity(updatedPromptNode)
+      };
+    } catch (error) {
+      console.log("Error fetching prompt, using fallback:", error);
+      return {
+        text: evaluateEntity(node)
+      };
+    }
+  }
+  async track(id, messages, options) {
+    await this.makeRequest("/insert_runs", "POST", {
+      id,
+      messages,
+      sessionId: options.sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+function createHoneClient(config) {
+  return new Hone(config);
+}
+
+// src/providers.ts
+var AIProvider = /* @__PURE__ */ ((AIProvider2) => {
+  AIProvider2["OpenAI"] = "openai";
+  AIProvider2["Anthropic"] = "anthropic";
+  AIProvider2["Google"] = "google";
+  AIProvider2["GoogleVertex"] = "google-vertex";
+  AIProvider2["Azure"] = "azure";
+  AIProvider2["XAI"] = "xai";
+  AIProvider2["Mistral"] = "mistral";
+  AIProvider2["Cohere"] = "cohere";
+  AIProvider2["Groq"] = "groq";
+  AIProvider2["TogetherAI"] = "togetherai";
+  AIProvider2["Fireworks"] = "fireworks";
+  AIProvider2["DeepInfra"] = "deepinfra";
+  AIProvider2["DeepSeek"] = "deepseek";
+  AIProvider2["Cerebras"] = "cerebras";
+  AIProvider2["Perplexity"] = "perplexity";
+  AIProvider2["AmazonBedrock"] = "amazon-bedrock";
+  AIProvider2["Baseten"] = "baseten";
+  return AIProvider2;
+})(AIProvider || {});
+var AI_PROVIDER_VALUES = Object.values(
+  AIProvider
+);
+function isValidProvider(value) {
+  return AI_PROVIDER_VALUES.includes(value);
+}
+var PROVIDER_DISPLAY_NAMES = {
+  openai: "OpenAI",
+  anthropic: "Anthropic",
+  google: "Google AI",
+  "google-vertex": "Google Vertex AI",
+  azure: "Azure OpenAI",
+  xai: "xAI",
+  mistral: "Mistral AI",
+  cohere: "Cohere",
+  groq: "Groq",
+  togetherai: "Together.ai",
+  fireworks: "Fireworks",
+  deepinfra: "DeepInfra",
+  deepseek: "DeepSeek",
+  cerebras: "Cerebras",
+  perplexity: "Perplexity",
+  "amazon-bedrock": "Amazon Bedrock",
+  baseten: "Baseten"
+};
+function getProviderDisplayName(provider) {
+  return PROVIDER_DISPLAY_NAMES[provider] || provider;
+}
+
+// src/tools.ts
+function createToolCallMessage(toolCalls, content = "") {
+  return {
+    role: "assistant",
+    content,
+    tool_calls: toolCalls
+  };
+}
+function createToolResultMessage(toolCallId, result) {
+  const content = typeof result === "string" ? result : JSON.stringify(result);
+  return {
+    role: "tool",
+    content,
+    tool_call_id: toolCallId
+  };
+}
+function extractOpenAIMessages(response) {
+  const messages = [];
+  for (const choice of response.choices) {
+    const msg = choice.message;
+    const message = {
+      role: msg.role,
+      content: msg.content ?? ""
+    };
+    if (msg.tool_calls && msg.tool_calls.length > 0) {
+      message.tool_calls = msg.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: tc.function.arguments
+      }));
+    }
+    messages.push(message);
+  }
+  return messages;
+}
+function extractAnthropicMessages(response) {
+  const messages = [];
+  const textBlocks = response.content.filter(
+    (block) => block.type === "text"
+  );
+  const toolUseBlocks = response.content.filter(
+    (block) => block.type === "tool_use"
+  );
+  const textContent = textBlocks.map((b) => b.text).join("\n");
+  if (toolUseBlocks.length > 0) {
+    const toolCalls = toolUseBlocks.map((block) => ({
+      id: block.id,
+      name: block.name,
+      arguments: JSON.stringify(block.input)
+    }));
+    messages.push({
+      role: "assistant",
+      content: textContent,
+      tool_calls: toolCalls
+    });
+  } else {
+    messages.push({
+      role: response.role,
+      content: textContent
+    });
+  }
+  return messages;
+}
+function extractGeminiMessages(response) {
+  const messages = [];
+  if (!response.candidates || response.candidates.length === 0) {
+    return messages;
+  }
+  for (const candidate of response.candidates) {
+    if (!candidate.content?.parts) continue;
+    const textParts = [];
+    const functionCalls = [];
+    for (const part of candidate.content.parts) {
+      if ("text" in part) {
+        textParts.push(part.text);
+      } else if ("functionCall" in part) {
+        functionCalls.push(part.functionCall);
+      }
+    }
+    const textContent = textParts.join("\n");
+    if (functionCalls.length > 0) {
+      const toolCalls = functionCalls.map((fc, index) => ({
+        id: `gemini_${fc.name}_${index}_${Date.now()}`,
+        name: fc.name,
+        arguments: JSON.stringify(fc.args)
+      }));
+      messages.push({
+        role: "assistant",
+        content: textContent,
+        tool_calls: toolCalls
+      });
+    } else if (textContent) {
+      messages.push({
+        role: candidate.content.role === "model" ? "assistant" : candidate.content.role || "assistant",
+        content: textContent
+      });
+    }
+  }
+  return messages;
+}
+var toolResult = createToolResultMessage;
+var fromOpenAI = extractOpenAIMessages;
+var fromAnthropic = extractAnthropicMessages;
+var fromGemini = extractGeminiMessages;
+
+exports.AIProvider = AIProvider;
+exports.AI_PROVIDER_VALUES = AI_PROVIDER_VALUES;
+exports.Hone = Hone;
+exports.createHoneClient = createHoneClient;
+exports.createToolCallMessage = createToolCallMessage;
+exports.createToolResultMessage = createToolResultMessage;
+exports.evaluateAgent = evaluateAgent;
+exports.evaluatePrompt = evaluatePrompt;
+exports.extractAnthropicMessages = extractAnthropicMessages;
+exports.extractGeminiMessages = extractGeminiMessages;
+exports.extractOpenAIMessages = extractOpenAIMessages;
+exports.formatAgentRequest = formatAgentRequest;
+exports.formatPromptRequest = formatPromptRequest;
+exports.fromAnthropic = fromAnthropic;
+exports.fromGemini = fromGemini;
+exports.fromOpenAI = fromOpenAI;
+exports.getAgentNode = getAgentNode;
+exports.getPromptNode = getPromptNode;
+exports.getProviderDisplayName = getProviderDisplayName;
+exports.insertParamsIntoPrompt = insertParamsIntoPrompt;
+exports.isValidProvider = isValidProvider;
+exports.toolResult = toolResult;
+exports.traverseAgentNode = traverseAgentNode;
+exports.traversePromptNode = traversePromptNode;
+exports.updateAgentNodes = updateAgentNodes;
+exports.updatePromptNodes = updatePromptNodes;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map