TypeScript LLM Adapters

Copyexport interface LLMResponse {
  content: string;
  role: string;
  toolCalls?: Array<{
    name: string;
    arguments: string;
  }>;
}
 
export interface LLM {
  generateResponse(
    messages: Array<{ role: string; content: string }>,
    response_format?: { type: string },
    tools?: any[],
  ): Promise<any>;
  generateChat(messages: Message[]): Promise<LLMResponse>;
}

Copyconst PROVIDERS = [
  "ai21",
  "amazon",
  "anthropic",
  "cohere",
  "meta",
  "mistral",
  "stability",
  "writer",
  "deepseek",
  "gpt-oss",
  "perplexity",
  "snowflake",
  "titan",
  "command",
  "j2",
  "llama",
  "minimax",
];

Copyexport function extractProvider(
  model: string,
  providerOverride?: string,
): string {
  if (providerOverride) {
    if (!PROVIDERS.includes(providerOverride)) {
      throw new Error(
        `Unknown providerOverride '${providerOverride}'. Valid providers: ${PROVIDERS.join(", ")}`,
      );
    }
    return providerOverride;
  }
  for (const provider of PROVIDERS) {
    const re = new RegExp(
      `\\b${provider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`,
    );
    if (re.test(model)) return provider;
  }
  throw new Error(`Unknown provider in model: ${model}`);
}

Copy/**
 * Split messages into a top-level `system` block (Converse passes system
 * prompts separately) and role-tagged content blocks for everything else.
 */
private formatMessages(messages: Message[]): {
  system?: { text: string }[];
  converseMessages: { role: string; content: { text: string }[] }[];
} {
  const systemParts: string[] = [];
  const converseMessages: { role: string; content: { text: string }[] }[] =
    [];
 
  for (const msg of messages) {
    const role = msg.role;
    const content =
      typeof msg.content === "string"
        ? msg.content
        : JSON.stringify(msg.content);
    if (role === "system") {
      systemParts.push(content);
    } else {
      converseMessages.push({
        role: role === "assistant" ? "assistant" : "user",
        content: [{ text: content }],
      });
    }
  }
 
  if (converseMessages.length === 0) {
    converseMessages.push({ role: "user", content: [{ text: "" }] });
  }
 
  return {
    system: systemParts.length
      ? [{ text: systemParts.join("\n") }]
      : undefined,
    converseMessages,
  };
}

Copyexport class OllamaLLM implements LLM {
  private ollama!: Ollama;
  private model: string;
  private readonly host: string;
  // Using this variable to avoid calling the Ollama server multiple times
  private initialized: boolean = false;
 
  constructor(config: LLMConfig) {
    this.host = config.url || config.baseURL || "http://localhost:11434";
    this.model = config.model || "llama3.1:8b";
    this.ensureModelExists().catch((err) => {
      logger.error(`Error ensuring model exists: ${err}`);
    });
  }
 
  private async ensureClient(): Promise<void> {
    if (this.ollama) return;
    const sdk = await loadPeer("ollama", "Ollama LLM", () => import("ollama"));
    this.ollama = new sdk.Ollama({ host: this.host });
  }

Copyprivate async ensureModelExists(): Promise<boolean> {
  if (this.initialized) {
    return true;
  }
  await this.ensureClient();
  const local_models = await this.ollama.list();
  if (!local_models.models.find((m: any) => m.name === this.model)) {
    logger.info(`Pulling model ${this.model}...`);
    await this.ollama.pull({ model: this.model });
  }
  this.initialized = true;
  return true;
}

Copyexport class LangchainLLM implements LLM {
  private llmInstance: BaseLanguageModel;
  private modelName: string;
 
  constructor(config: LLMConfig) {
    if (!config.model || typeof config.model !== "object") {
      throw new Error(
        "Langchain provider requires an initialized Langchain instance passed via the 'model' field in the LLM config.",
      );
    }
    if (typeof (config.model as any).invoke !== "function") {
      throw new Error(
        "Provided Langchain 'instance' in the 'model' field does not appear to be a valid Langchain language model (missing invoke method).",
      );
    }
    this.llmInstance = config.model as BaseLanguageModel;
    this.modelName =
      (this.llmInstance as any).modelId ||
      (this.llmInstance as any).model ||
      "langchain-model";
  }

Copyconst convertToLangchainMessages = async (
  messages: Message[],
): Promise<BaseMessage[]> => {
  const { AIMessage, HumanMessage, SystemMessage } =
    await import("@langchain/core/messages");
  return messages.map((msg) => {
    const content =
      typeof msg.content === "string"
        ? msg.content
        : JSON.stringify(msg.content);
    switch (msg.role?.toLowerCase()) {
      case "system":
        return new SystemMessage(content);
      case "user":
      case "human":
        return new HumanMessage(content);
      case "assistant":
      case "ai":
        return new AIMessage(content);
      default:
        console.warn(
          `Unsupported message role '${msg.role}' for Langchain. Treating as 'human'.`,
        );
        return new HumanMessage(content);
    }
  });
};

Copy// --- Internal Schema Selection Logic (runs regardless of response_format) ---
const systemPromptContent =
  (messages.find((m) => m.role === "system")?.content as string) || "";
const userPromptContent =
  (messages.find((m) => m.role === "user")?.content as string) || "";
// Check for memory prompts
if (
  systemPromptContent.includes("Personal Information Organizer") &&
  systemPromptContent.includes("extract relevant pieces of information")
) {
  selectedSchema = FactRetrievalSchema;
} else if (
  userPromptContent.includes("smart memory manager") &&
  userPromptContent.includes("Compare newly retrieved facts")
) {
  selectedSchema = MemoryUpdateSchema;
}
 
// --- Apply Structured Output if Schema Selected ---
if (
  selectedSchema &&
  typeof (this.llmInstance as any).withStructuredOutput === "function"
) {
  try {
    runnable = (this.llmInstance as any).withStructuredOutput(
      selectedSchema,
      { name: tools?.[0]?.function.name },
    );
    isStructuredOutput = true;
  } catch (e) {
    isStructuredOutput = false; // Ensure flag is false on error
    // No fallback to response_format here unless explicitly passed
    if (response_format?.type === "json_object") {
      invokeOptions.response_format = { type: "json_object" };
    }
  }
} else if (selectedSchema && response_format?.type === "json_object") {
  // Schema selected, but no .withStructuredOutput. Try basic response_format only if explicitly requested.
  if (
    (this.llmInstance as any)._identifyingParams?.response_format ||
    (this.llmInstance as any).response_format
  ) {
    invokeOptions.response_format = { type: "json_object" };
  }
} else if (!selectedSchema && response_format?.type === "json_object") {
  // Explicit JSON request, but no schema inferred. Try basic response_format.
  if (
    (this.llmInstance as any)._identifyingParams?.response_format ||
    (this.llmInstance as any).response_format
  ) {
    invokeOptions.response_format = { type: "json_object" };
  }
}
 
// --- Handle tool binding ---
if (tools && tools.length > 0) {
  if (typeof (runnable as any).bindTools === "function") {
    try {
      runnable = (runnable as any).bindTools(tools);
    } catch (e) {}
  } else {
  }
}