@tyvm/knowhow 0.0.1

package/src/clients/index.ts

@@ -0,0 +1,183 @@
+import {
+  CompletionOptions,
+  CompletionResponse,
+  EmbeddingOptions,
+  EmbeddingResponse,
+  GenericClient,
+} from "./types";
+import { GenericOpenAiClient } from "./openai";
+import { GenericAnthropicClient } from "./anthropic";
+import { GenericGeminiClient } from "./gemini";
+import { HttpClient } from "./http";
+import { Models } from "../types";
+import { getConfig } from "../config";
+import { GenericXAIClient } from "./xai";
+
+function envCheck(key: string): boolean {
+  const value = process.env[key];
+  if (!value) {
+    return false;
+  }
+  return true;
+}
+
+export class AIClient {
+  clients = {
+    ...(envCheck("OPENAI_KEY") && { openai: new GenericOpenAiClient() }),
+
+    ...(envCheck("ANTHROPIC_API_KEY") && {
+      anthropic: new GenericAnthropicClient(),
+    }),
+
+    ...(envCheck("GEMINI_API_KEY") && { google: new GenericGeminiClient() }),
+    ...(envCheck("XAI_API_KEY") && { xai: new GenericXAIClient() }),
+  };
+
+  clientModels = {
+    ...(envCheck("OPENAI_KEY") && { openai: Object.values(Models.openai) }),
+    ...(envCheck("ANTHROPIC_API_KEY") && {
+      anthropic: Object.values(Models.anthropic),
+    }),
+    ...(envCheck("GEMINI_API_KEY") && { google: Object.values(Models.google) }),
+    ...(envCheck("XAI_API_KEY") && { xai: Object.values(Models.xai) }),
+  };
+
+  getClient(provider: string, model?: string) {
+    if (this.clients[provider]) {
+      return { client: this.clients[provider], provider, model };
+    }
+
+    const detected = this.detectProviderModel(provider, model);
+
+    provider = detected.provider;
+    model = detected.model;
+
+    if (!this.clients[provider]) {
+      throw new Error(
+        `Provider ${provider} for model ${model} not registered. Available providers: ${Object.keys(
+          this.clients
+        )}`
+      );
+    }
+
+    const hasModel = this.providerHasModel(provider, model);
+
+    if (!hasModel) {
+      throw new Error(
+        `Model ${model} not registered for provider ${provider}.`
+      );
+    }
+
+    return { client: this.clients[provider], provider, model };
+  }
+
+  registerClient(provider: string, client: GenericClient) {
+    this.clients[provider] = client;
+  }
+
+  async registerConfiguredModels() {
+    const config = await getConfig();
+    const modelProviders = config.modelProviders || [];
+
+    for (const modelProvider of modelProviders) {
+      const client = new HttpClient(modelProvider.url, modelProvider.headers);
+
+      if (modelProvider.jwtFile) {
+        client.loadJwtFile(modelProvider.jwtFile);
+      }
+
+      this.registerClient(modelProvider.provider, client);
+
+      try {
+        const models = await client.getModels();
+        const ids = models.map((model) => model.id);
+        this.registerModels(modelProvider.provider, ids);
+      } catch (error) {
+        console.error(
+          `Failed to register models for provider ${modelProvider.provider}:`,
+          error.message
+        );
+      }
+    }
+  }
+
+  registerModels(provider: string, models: string[]) {
+    const currentModels = this.clientModels[provider] || [];
+    this.clientModels[provider] = Array.from<string>(
+      new Set(currentModels.concat(models))
+    );
+  }
+
+  private providerHasModel(provider: string, model: string): boolean {
+    const models = this.clientModels[provider];
+    if (!models) return false;
+    return models.includes(model);
+  }
+
+  private detectProviderModel(provider: string, model: string) {
+    if (this.providerHasModel(provider, model)) {
+      return { provider, model };
+    }
+
+    if (model.includes("/")) {
+      const split = model.split("/");
+
+      const inferredProvider = split[0];
+      const inferredModel = split.slice(1).join("/");
+
+      if (this.providerHasModel(inferredProvider, inferredModel)) {
+        return { provider: inferredProvider, model: inferredModel };
+      }
+    }
+
+    const providers = Object.keys(this.clientModels);
+    const foundProvider = providers.find((p) =>
+      this.providerHasModel(p, model)
+    );
+
+    if (foundProvider) {
+      return { provider: foundProvider, model };
+    }
+
+    return { provider, model };
+  }
+
+  async createCompletion(
+    provider: string,
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const { client, model } = this.getClient(provider, options.model);
+    return client.createChatCompletion({ ...options, model });
+  }
+
+  async createEmbedding(
+    provider: string,
+    options: EmbeddingOptions
+  ): Promise<EmbeddingResponse> {
+    const { client, model } = this.getClient(provider, options.model);
+    return client.createEmbedding({ ...options, model });
+  }
+
+  getRegisteredModels(provider: string): string[] {
+    return this.clientModels[provider] || [];
+  }
+
+  listAllModels() {
+    return this.clientModels;
+  }
+
+  listAllProviders() {
+    return Object.keys(this.clientModels);
+  }
+}
+
+export const Clients = new AIClient();
+
+export * from "./types";
+
+export * from "./http";
+export * from "./openai";
+export * from "./anthropic";
+export * from "./knowhow";
+export * from "./gemini";
+export * from "./xai";

package/src/clients/knowhow.ts

@@ -0,0 +1,33 @@
+import {
+  GenericClient,
+  CompletionOptions,
+  CompletionResponse,
+  EmbeddingOptions,
+  EmbeddingResponse,
+} from "./types";
+import { KnowhowSimpleClient } from "../services/KnowhowClient";
+
+export class KnowhowGenericClient implements GenericClient {
+  private client: KnowhowSimpleClient;
+
+  constructor(baseUrl: string, jwt?: string) {
+    this.client = new KnowhowSimpleClient(baseUrl, jwt);
+  }
+
+  async createChatCompletion(
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const response = await this.client.createChatCompletion(options);
+    return response.data;
+  }
+
+  async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
+    const response = await this.client.createEmbedding(options);
+    return response.data;
+  }
+
+  async getModels(): Promise<{ id: string }[]> {
+    const response = await this.client.getModels();
+    return response.data;
+  }
+}

package/src/clients/openai.ts

@@ -0,0 +1,253 @@
+import OpenAI from "openai";
+import { getConfigSync } from "../config";
+import {
+  GenericClient,
+  CompletionOptions,
+  CompletionResponse,
+  EmbeddingOptions,
+  EmbeddingResponse,
+} from "./types";
+import {
+  ChatCompletionMessageParam,
+  ChatCompletionToolMessageParam,
+  ChatCompletionMessageToolCall,
+} from "openai/resources/chat";
+
+import { Models, OpenAiReasoningModels } from "../types";
+
+const config = getConfigSync();
+
+export class GenericOpenAiClient extends OpenAI implements GenericClient {
+  constructor() {
+    super({
+      apiKey: process.env.OPENAI_KEY,
+      ...(config.openaiBaseUrl && { baseURL: config.openaiBaseUrl }),
+    });
+  }
+
+  async createChatCompletion(
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const openaiMessages = options.messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          ...msg,
+          content: msg.content || "",
+          role: "tool",
+          tool_call_id: msg.tool_call_id,
+        } as ChatCompletionToolMessageParam;
+      }
+      return msg as ChatCompletionMessageParam;
+    });
+
+    const response = await this.chat.completions.create({
+      model: options.model,
+      messages: openaiMessages,
+      max_tokens: options.max_tokens,
+      ...(OpenAiReasoningModels.includes(options.model) && {
+        max_tokens: undefined,
+        max_completion_tokens: options.max_tokens,
+      }),
+
+      ...(options.tools && {
+        tools: options.tools,
+        tool_choice: "auto",
+      }),
+    });
+
+    console.log(JSON.stringify({ response }, null, 2));
+    const usdCost = this.calculateCost(options.model, response.usage);
+
+    return {
+      choices: response.choices.map((choice) => ({
+        message: {
+          role: choice.message?.role || "assistant",
+          content: choice.message?.content || null,
+          tool_calls: choice.message?.tool_calls
+            ? choice.message.tool_calls
+            : undefined,
+        },
+      })),
+
+      model: options.model,
+      usage: response.usage,
+      usd_cost: usdCost,
+    };
+  }
+
+  pricesPerMillion() {
+    return {
+      [Models.openai.GPT_4o]: {
+        input: 2.5,
+        cached_input: 1.25,
+        output: 10.0,
+      },
+      [Models.openai.GPT_4o_Mini]: {
+        input: 0.15,
+        cached_input: 0.075,
+        output: 0.6,
+      },
+      [Models.openai.o1]: {
+        input: 15.0,
+        cached_input: 7.5,
+        output: 60.0,
+      },
+      [Models.openai.o1_Mini]: {
+        input: 1.1,
+        cached_input: 0.55,
+        output: 4.4,
+      },
+      [Models.openai.o3_Mini]: {
+        input: 1.1,
+        cached_input: 0.55,
+        output: 4.4,
+      },
+      [Models.openai.GPT_41]: {
+        input: 2.0,
+        cached_input: 0.5,
+        output: 8.0,
+      },
+      [Models.openai.GPT_41_Mini]: {
+        input: 0.4,
+        cached_input: 0.1,
+        output: 1.6,
+      },
+      [Models.openai.GPT_41_Nano]: {
+        input: 0.1,
+        cached_input: 0.025,
+        output: 0.4,
+      },
+      [Models.openai.GPT_45]: {
+        input: 75.0,
+        cached_input: 37.5,
+        output: 150.0,
+      },
+      [Models.openai.GPT_4o_Audio]: {
+        input: 2.5,
+        cached_input: 0,
+        output: 10.0,
+      },
+      [Models.openai.GPT_4o_Realtime]: {
+        input: 5.0,
+        cached_input: 2.5,
+        output: 20.0,
+      },
+      [Models.openai.GPT_4o_Mini_Audio]: {
+        input: 0.15,
+        cached_input: 0,
+        output: 0.6,
+      },
+      [Models.openai.GPT_4o_Mini_Realtime]: {
+        input: 0.6,
+        cached_input: 0.3,
+        output: 2.4,
+      },
+      [Models.openai.o1_Pro]: {
+        input: 150.0,
+        cached_input: 0,
+        output: 600.0,
+      },
+      [Models.openai.o3]: {
+        input: 10.0,
+        cached_input: 2.5,
+        output: 40.0,
+      },
+      [Models.openai.o4_Mini]: {
+        input: 1.1,
+        cached_input: 0.275,
+        output: 4.4,
+      },
+      [Models.openai.GPT_4o_Mini_Search]: {
+        input: 0.15,
+        cached_input: 0,
+        output: 0.6,
+      },
+      [Models.openai.GPT_4o_Search]: {
+        input: 2.5,
+        cached_input: 0,
+        output: 10.0,
+      },
+      [Models.openai.Computer_Use]: {
+        input: 3.0,
+        cached_input: 0,
+        output: 12.0,
+      },
+      [Models.openai.Codex_Mini]: {
+        input: 1.5,
+        cached_input: 0.375,
+        output: 6.0,
+      },
+      [Models.openai.EmbeddingAda2]: {
+        input: 0.1,
+        cached_input: 0,
+        output: 0,
+      },
+      [Models.openai.EmbeddingLarge3]: {
+        input: 0.13,
+        cached_input: 0,
+        output: 0,
+      },
+      [Models.openai.EmbeddingLarge3]: {
+        input: 0.02,
+        cached_input: 0,
+        output: 0,
+      },
+    };
+  }
+
+  calculateCost(
+    model: string,
+    usage:
+      | OpenAI.ChatCompletion["usage"]
+      | OpenAI.CreateEmbeddingResponse["usage"]
+  ): number | undefined {
+    const pricing = this.pricesPerMillion()[model];
+
+    console.log({ pricing });
+    if (!pricing) {
+      return undefined;
+    }
+
+    const cachedInputTokens =
+      ("prompt_tokens_details" in usage &&
+        usage.prompt_tokens_details?.cached_tokens) ||
+      0;
+    const cachedInputCost = (cachedInputTokens * pricing.cached_input) / 1e6;
+
+    const inputTokens = usage.prompt_tokens;
+    const inputCost = ((inputTokens - cachedInputCost) * pricing.input) / 1e6;
+
+    const outputTokens =
+      ("completion_tokens" in usage && usage?.completion_tokens) || 0;
+    const outputCost = (outputTokens * pricing.output) / 1e6;
+
+    const total = cachedInputCost + inputCost + outputCost;
+    console.log({ total });
+    return total;
+  }
+
+  async getModels() {
+    const models = await this.models.list();
+    return models.data.map((m) => {
+      return {
+        id: m.id,
+        object: m.object,
+        owned_by: m.owned_by,
+      };
+    });
+  }
+
+  async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
+    const openAiEmbedding = await this.embeddings.create({
+      input: options.input,
+      model: options.model,
+    });
+
+    return {
+      data: openAiEmbedding.data,
+      model: options.model,
+      usage: openAiEmbedding.usage,
+      usd_cost: this.calculateCost(options.model, openAiEmbedding.usage),
+    };
+  }
+}

package/src/clients/types.ts

@@ -0,0 +1,91 @@
+export type MessageContent =
+  | { type: "text"; text: string }
+  | { type: "image_url"; image_url: { url: string } };
+
+export interface Message {
+  role: "system" | "user" | "assistant" | "tool";
+  content: string | MessageContent[];
+
+  name?: string;
+  tool_call_id?: string;
+  tool_calls?: ToolCall[];
+}
+
+export interface OutputMessage extends Message {
+  content: string;
+}
+
+export interface ToolProp {
+  type: string;
+  description: string;
+  properties?: { [key: string]: ToolProp };
+  items?: ToolProp;
+}
+
+export interface Tool {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: string;
+      positional?: boolean;
+      properties: {
+        [key: string]: ToolProp;
+      };
+      required: string[];
+    };
+  };
+}
+
+export interface ToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface CompletionOptions {
+  model: string;
+  messages: Message[];
+  tools?: Tool[];
+  tool_choice?: "auto" | "none";
+  max_tokens?: number;
+}
+
+export interface CompletionResponse {
+  choices: {
+    message: OutputMessage;
+  }[];
+
+  model: string;
+  usage: any;
+  usd_cost?: number;
+}
+
+export interface EmbeddingOptions {
+  input: string;
+  model?: string;
+}
+
+export interface EmbeddingResponse {
+  data: {
+    object: string;
+    embedding: number[];
+    index: number;
+  }[];
+  model: string;
+  usage: {
+    prompt_tokens: number;
+    total_tokens: number;
+  };
+  usd_cost?: number;
+}
+
+export interface GenericClient {
+  createChatCompletion(options: CompletionOptions): Promise<CompletionResponse>;
+  createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse>;
+  getModels(): Promise<{ id: string }[]>;
+}

package/src/clients/xai.ts

@@ -0,0 +1,132 @@
+import OpenAI from "openai";
+import { getConfigSync } from "../config";
+import {
+  GenericClient,
+  CompletionOptions,
+  CompletionResponse,
+  EmbeddingOptions,
+  EmbeddingResponse,
+} from "./types";
+import {
+  ChatCompletionMessageParam,
+  ChatCompletionToolMessageParam,
+} from "openai/resources/chat";
+
+import { Models } from "../types";
+
+const config = getConfigSync();
+
+export class GenericXAIClient extends OpenAI implements GenericClient {
+  constructor() {
+    super({
+      apiKey: process.env.XAI_API_KEY,
+      baseURL: "https://api.x.ai/v1",
+    });
+  }
+
+  async createChatCompletion(
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const xaiMessages = options.messages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          ...msg,
+          content: msg.content || "",
+          role: "tool",
+          tool_call_id: msg.tool_call_id,
+        } as ChatCompletionToolMessageParam;
+      }
+      return msg as ChatCompletionMessageParam;
+    });
+
+    const response = await this.chat.completions.create({
+      model: options.model,
+      messages: xaiMessages,
+      max_tokens: options.max_tokens,
+      ...(options.tools && {
+        tools: options.tools,
+        tool_choice: "auto",
+      }),
+    });
+
+    console.log(JSON.stringify({ response }, null, 2));
+    const usdCost = this.calculateCost(options.model, response.usage);
+    return {
+      choices: response.choices.map((choice) => ({
+        message: {
+          role: choice.message?.role || "assistant",
+          content: choice.message?.content || null,
+          tool_calls: choice.message?.tool_calls
+            ? choice.message.tool_calls
+            : undefined,
+        },
+      })),
+
+      model: options.model,
+      usage: response.usage,
+      usd_cost: usdCost,
+    };
+  }
+
+  pricesPerMillion() {
+    return {
+      [Models.xai.Grok3Beta]: {
+        input: 3.0,
+        output: 15.0,
+      },
+      [Models.xai.Grok3MiniBeta]: {
+        input: 0.3,
+        output: 0.5,
+      },
+      [Models.xai.Grok3FastBeta]: {
+        input: 5.0,
+        output: 25.0,
+      },
+      [Models.xai.Grok3MiniFastBeta]: {
+        input: 0.6,
+        output: 4.0,
+      },
+      [Models.xai.Grok21212]: {
+        input: 2.0,
+        output: 10.0,
+      },
+      [Models.xai.Grok2Vision1212]: {
+        input: 2.0,
+        output: 10.0,
+        image_input: 2.0,
+      },
+    };
+  }
+
+  calculateCost(
+    model: string,
+    usage: OpenAI.ChatCompletion["usage"]
+  ): number | undefined {
+    const pricing = this.pricesPerMillion()[model];
+
+    if (!pricing) {
+      return undefined;
+    }
+
+    const inputTokens = usage.prompt_tokens;
+    const inputCost = (inputTokens * pricing.input) / 1e6;
+
+    const outputTokens = usage.completion_tokens || 0;
+    const outputCost = (outputTokens * pricing.output) / 1e6;
+
+    const total = inputCost + outputCost;
+    console.log({ total });
+    return total;
+  }
+
+  async getModels() {
+    // XAI doesn't provide a model listing endpoint, so we'll return the static list
+    return Object.keys(Models.xai).map((key) => ({
+      id: Models.xai[key],
+    }));
+  }
+
+  async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
+    throw new Error("XAI provider does not support embeddings");
+  }
+}