@p-sw/brainbox 0.1.0 → 0.1.2-alpha.0

package/src/provider/providers/snowflake_cortex.ts

@@ -1,207 +0,0 @@
-import { logger } from "@/utils/logger";
-import { z } from "zod";
-import {
-  LLMExecutor,
-  defaultReasoningEffort,
-  readAuthString,
-  type CallOptions,
-  type ChatChoice,
-  type ChatFunctionTool,
-  type ChatMessages,
-  type ChatWithToolsOptions,
-  type ToolCall,
-} from "../llm";
-
-const CortexAuthSchema = z
-  .object({
-    account: z.string().optional(),
-  })
-  .loose();
-
-type CortexTool = {
-  type: "function";
-  function: {
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
-  };
-};
-
-type CortexMessageWire =
-  | { role: "system" | "user"; content: string }
-  | {
-      role: "assistant";
-      content: string | null;
-      tool_calls?: Array<{
-        id: string;
-        type: "function";
-        function: { name: string; arguments: unknown };
-      }>;
-    }
-  | { role: "tool"; content: string; tool_call_id: string };
-
-type CortexResponse = {
-  choices?: Array<{
-    message?: {
-      content?: string | null;
-      tool_calls?: Array<{
-        id: string;
-        type: "function";
-        function: { name: string; arguments: unknown };
-      }>;
-    };
-  }>;
-  message?: string;
-  error?: { message?: string };
-};
-
-function toCortexMessage(m: ChatMessages): CortexMessageWire {
-  if (m.role === "assistant") {
-    return {
-      role: "assistant",
-      content: m.content ?? null,
-      tool_calls: m.toolCalls?.map((c) => ({
-        id: c.id,
-        type: "function",
-        function: { name: c.function.name, arguments: c.function.arguments },
-      })),
-    };
-  }
-  if (m.role === "tool") {
-    return { role: "tool", content: m.content, tool_call_id: m.toolCallId };
-  }
-  return { role: m.role, content: m.content };
-}
-
-function toCortexTool(t: ChatFunctionTool): CortexTool {
-  return {
-    type: "function",
-    function: {
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters ?? { type: "object", properties: {} },
-    },
-  };
-}
-
-export class SnowflakeCortexExecutor extends LLMExecutor {
-  readonly providerName = "snowflake-cortex";
-  readonly models: { conversation: string; identity: string };
-
-  private readonly apiKey: string;
-  private readonly baseURL: string;
-
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-    auth?: Record<string, unknown>;
-  }) {
-    super();
-    this.models = {
-      conversation: opts.conversationModel,
-      identity: opts.identityModel,
-    };
-    this.apiKey = opts.apiKey;
-    const parsed = CortexAuthSchema.safeParse(opts.auth ?? {});
-    const extra = parsed.success ? parsed.data : {};
-    const account =
-      extra.account ??
-      readAuthString(opts.auth, "account", "SNOWFLAKE_ACCOUNT") ??
-      "";
-    this.baseURL = account
-      ? `https://${account}.snowflakecomputing.com/api/v2/cortex/inference:complete`
-      : "https://__account__.snowflakecomputing.com/api/v2/cortex/inference:complete";
-  }
-
-  private async send(body: Record<string, unknown>): Promise<CortexResponse> {
-    const res = await fetch(this.baseURL, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(
-        `snowflake-cortex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`,
-      );
-    }
-    return (await res.json()) as CortexResponse;
-  }
-
-  async call<T>(model: string, options: CallOptions): Promise<T> {
-    const jsonMode = "jsonSchemaName" in options;
-    const reasoning = defaultReasoningEffort(
-      options.reasoningEffort,
-      model,
-      this.models.identity,
-    );
-    const log = logger.child("llm:snowflake-cortex");
-    log.debug(
-      `call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`,
-    );
-    const body: Record<string, unknown> = {
-      model,
-      messages: [
-        { role: "system", content: options.instruction },
-        { role: "user", content: options.message },
-      ],
-    };
-    if (reasoning !== "none") {
-      body["reasoning_effort"] = reasoning;
-    }
-    const data = await this.send(body);
-    if (data.error) {
-      throw new Error(
-        `snowflake-cortex API error: ${data.error.message ?? "unknown"}`,
-      );
-    }
-    const content = data.choices?.[0]?.message?.content ?? data.message ?? "";
-    if (!content) {
-      throw new Error("Empty response from model");
-    }
-    return (jsonMode ? JSON.parse(content) : content) as T;
-  }
-
-  async chatWithTools(
-    model: string,
-    options: ChatWithToolsOptions,
-  ): Promise<ChatChoice> {
-    const log = logger.child("llm:snowflake-cortex");
-    log.debug(
-      `chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`,
-    );
-    const body: Record<string, unknown> = {
-      model,
-      messages: [
-        { role: "system", content: options.instruction },
-        ...options.messages.map(toCortexMessage),
-      ],
-      tools: options.tools.map(toCortexTool),
-    };
-    const data = await this.send(body);
-    if (data.error) {
-      throw new Error(
-        `snowflake-cortex API error: ${data.error.message ?? "unknown"}`,
-      );
-    }
-    const choice = data.choices?.[0];
-    const content = choice?.message?.content ?? data.message ?? "";
-    const toolCalls: ToolCall[] | undefined = choice?.message?.tool_calls?.map(
-      (c) => ({
-        id: c.id,
-        function: {
-          name: c.function.name,
-          arguments:
-            typeof c.function.arguments === "string"
-              ? c.function.arguments
-              : JSON.stringify(c.function.arguments ?? {}),
-        },
-      }),
-    );
-    return { message: { content: content || undefined, toolCalls } };
-  }
-}

package/src/provider/providers/stackit.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class StackitExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "stackit",
-      baseURL: "https://api.openai-compat.openai-stackit.com/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/providers/together.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class TogetherExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "together",
-      baseURL: "https://api.together.xyz/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/providers/venice.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class VeniceExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "venice",
-      baseURL: "https://api.venice.ai/api/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/providers/vercel.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class VercelExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "vercel",
-      baseURL: "https://ai-gateway.vercel.sh/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/providers/vertex.ts

@@ -1,229 +0,0 @@
-import { logger } from "@/utils/logger";
-import { z } from "zod";
-import {
-  LLMExecutor,
-  defaultReasoningEffort,
-  readAuthString,
-  type CallOptions,
-  type ChatChoice,
-  type ChatFunctionTool,
-  type ChatMessages,
-  type ChatWithToolsOptions,
-  type ToolCall,
-} from "../llm";
-
-const VertexAuthSchema = z
-  .object({
-    project: z.string().optional(),
-    region: z.string().optional(),
-  })
-  .loose();
-
-type GeminiPart =
-  | { text: string }
-  | { functionCall: { name: string; args: Record<string, unknown> } }
-  | { functionResponse: { name: string; response: Record<string, unknown> } };
-
-type GeminiResponse = {
-  candidates?: Array<{
-    content?: { parts?: GeminiPart[]; role?: string };
-    finishReason?: string;
-  }>;
-  error?: { message?: string; code?: number };
-};
-
-function toGeminiContents(
-  messages: ChatMessages[],
-): Array<{ role: string; parts: GeminiPart[] }> {
-  const out: Array<{ role: string; parts: GeminiPart[] }> = [];
-  for (const m of messages) {
-    if (m.role === "system") continue; // system goes into systemInstruction
-    if (m.role === "user") {
-      out.push({ role: "user", parts: [{ text: m.content }] });
-      continue;
-    }
-    if (m.role === "assistant") {
-      const parts: GeminiPart[] = [];
-      if (m.content) parts.push({ text: m.content });
-      if (m.toolCalls) {
-        for (const c of m.toolCalls) {
-          let args: Record<string, unknown> = {};
-          try {
-            args = c.function.arguments ? JSON.parse(c.function.arguments) : {};
-          } catch {
-            args = {};
-          }
-          parts.push({ functionCall: { name: c.function.name, args } });
-        }
-      }
-      out.push({ role: "model", parts });
-      continue;
-    }
-    if (m.role === "tool") {
-      let response: Record<string, unknown> = {};
-      try {
-        response = JSON.parse(m.content);
-      } catch {
-        response = { result: m.content };
-      }
-      // ponytail: We don't track the original tool name on tool messages; the
-      // caller names the response. The wire response uses an empty name.
-      out.push({
-        role: "user",
-        parts: [{ functionResponse: { name: "", response } }],
-      });
-    }
-  }
-  return out;
-}
-
-function toGeminiTool(t: ChatFunctionTool) {
-  return {
-    functionDeclarations: [
-      {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters ?? { type: "object", properties: {} },
-      },
-    ],
-  };
-}
-
-function extractFromGemini(data: GeminiResponse): {
-  text: string;
-  toolCalls: ToolCall[] | undefined;
-} {
-  const parts = data.candidates?.[0]?.content?.parts ?? [];
-  let text = "";
-  const toolCalls: ToolCall[] = [];
-  let idx = 0;
-  for (const p of parts) {
-    if ("text" in p) text += p.text;
-    if ("functionCall" in p) {
-      toolCalls.push({
-        id: `call_${idx++}`,
-        function: {
-          name: p.functionCall.name,
-          arguments: JSON.stringify(p.functionCall.args ?? {}),
-        },
-      });
-    }
-  }
-  return { text, toolCalls: toolCalls.length > 0 ? toolCalls : undefined };
-}
-
-export class VertexExecutor extends LLMExecutor {
-  readonly providerName = "vertex";
-  readonly models: { conversation: string; identity: string };
-
-  private readonly apiKey: string;
-  private readonly project: string;
-  private readonly region: string;
-  private readonly baseURL: string;
-
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-    auth?: Record<string, unknown>;
-  }) {
-    super();
-    this.models = {
-      conversation: opts.conversationModel,
-      identity: opts.identityModel,
-    };
-    this.apiKey = opts.apiKey;
-    const parsed = VertexAuthSchema.safeParse(opts.auth ?? {});
-    const extra = parsed.success ? parsed.data : {};
-    this.project =
-      extra.project ??
-      readAuthString(opts.auth, "project", "GOOGLE_CLOUD_PROJECT") ??
-      "";
-    this.region =
-      extra.region ??
-      readAuthString(opts.auth, "region", "GOOGLE_CLOUD_REGION") ??
-      "us-central1";
-    this.baseURL = this.project
-      ? `https://${this.region}-aiplatform.googleapis.com/v1/projects/${this.project}/locations/${this.region}/publishers/google/models`
-      : "https://us-central1-aiplatform.googleapis.com/v1";
-  }
-
-  private async generate(
-    model: string,
-    body: Record<string, unknown>,
-  ): Promise<GeminiResponse> {
-    const url = `${this.baseURL}/${encodeURIComponent(model)}:generateContent`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(
-        `vertex request failed: ${res.status} ${res.statusText} body=${text.slice(0, 500)}`,
-      );
-    }
-    return (await res.json()) as GeminiResponse;
-  }
-
-  async call<T>(model: string, options: CallOptions): Promise<T> {
-    const jsonMode = "jsonSchemaName" in options;
-    const log = logger.child("llm:vertex");
-    log.debug(
-      `call: model=${model} jsonSchema=${jsonMode ? options.jsonSchemaName : "-"} msgLen=${options.message.length}`,
-    );
-    const body: Record<string, unknown> = {
-      contents: [
-        {
-          role: "user",
-          parts: [{ text: options.message }],
-        },
-      ],
-      systemInstruction: { parts: [{ text: options.instruction }] },
-    };
-    if (jsonMode) {
-      body["generationConfig"] = {
-        responseMimeType: "application/json",
-        responseSchema: options.jsonSchema,
-      };
-    }
-    const data = await this.generate(model, body);
-    if (data.error) {
-      throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
-    }
-    const { text } = extractFromGemini(data);
-    if (!text) {
-      throw new Error("Empty response from model");
-    }
-    return (jsonMode ? JSON.parse(text) : text) as T;
-  }
-
-  async chatWithTools(
-    model: string,
-    options: ChatWithToolsOptions,
-  ): Promise<ChatChoice> {
-    const log = logger.child("llm:vertex");
-    log.debug(
-      `chatWithTools: model=${model} msgs=${options.messages.length} tools=${options.tools.length}`,
-    );
-    const contents = toGeminiContents(options.messages);
-    const body: Record<string, unknown> = {
-      contents,
-      systemInstruction: { parts: [{ text: options.instruction }] },
-      tools:
-        options.tools.length > 0
-          ? [toGeminiTool(options.tools[0]!)]
-          : undefined,
-    };
-    const data = await this.generate(model, body);
-    if (data.error) {
-      throw new Error(`vertex API error: ${data.error.message ?? "unknown"}`);
-    }
-    const { text, toolCalls } = extractFromGemini(data);
-    return { message: { content: text || undefined, toolCalls } };
-  }
-}

package/src/provider/providers/xai.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class XAIExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "xai",
-      baseURL: "https://api.x.ai/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/providers/zai.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class ZaiExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "zai",
-      baseURL: "https://api.z.ai/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/providers/zenmux.ts

@@ -1,17 +0,0 @@
-import { OpenAICompatibleExecutor } from "./openai_compatible";
-
-export class ZenMuxExecutor extends OpenAICompatibleExecutor {
-  constructor(opts: {
-    apiKey: string;
-    conversationModel: string;
-    identityModel: string;
-  }) {
-    super({
-      providerName: "zenmux",
-      baseURL: "https://zenmux.ai/api/v1",
-      apiKey: opts.apiKey,
-      conversationModel: opts.conversationModel,
-      identityModel: opts.identityModel,
-    });
-  }
-}

package/src/provider/schema.ts

@@ -1,143 +0,0 @@
-const timeString = {
-  type: "string",
-  pattern: "^([01][0-9]|2[0-3]):[0-5][0-9]$",
-};
-const endTimeString = {
-  type: "string",
-  pattern: "^([01][0-9]|2[0-3]):[0-5][0-9]$|^24:00$",
-};
-
-export const dailyScheduleSchema = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    items: {
-      type: "array",
-      minItems: 48,
-      maxItems: 48,
-      items: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          start: timeString,
-          end: endTimeString,
-          activity: { type: "string" },
-          notes: { type: "string" },
-        },
-        required: ["start", "end", "activity", "notes"],
-      },
-    },
-  },
-  required: ["items"],
-};
-
-export const monthlyScheduleSchema = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    items: {
-      type: "array",
-      minItems: 28,
-      maxItems: 31,
-      items: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          day: { type: "integer", minimum: 1, maximum: 31 },
-          summary: { type: "string" },
-        },
-        required: ["day", "summary"],
-      },
-    },
-  },
-  required: ["items"],
-};
-
-export const availabilitySchema = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    items: {
-      type: "array",
-      minItems: 1,
-      items: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          start: timeString,
-          end: endTimeString,
-          status: {
-            type: "string",
-            enum: ["online", "do-not-disturb", "offline"],
-          },
-        },
-        required: ["start", "end", "status"],
-      },
-    },
-  },
-  required: ["items"],
-};
-
-// ----------------------------------------------------------------------------
-// Types — co-located with their schemas.
-// ----------------------------------------------------------------------------
-
-export type DailySlot = {
-  start: string;
-  end: string;
-  activity: string;
-  notes: string;
-};
-
-export type DailySchedule = {
-  items: DailySlot[];
-};
-
-export type MonthlyDay = {
-  day: number;
-  summary: string;
-};
-
-export type MonthlySchedule = {
-  items: MonthlyDay[];
-};
-
-export type AvailabilityStatus = "online" | "do-not-disturb" | "offline";
-
-export type Availability = {
-  start: string;
-  end: string;
-  status: AvailabilityStatus;
-};
-
-export type AvailabilityWindows = {
-  items: Availability[];
-};
-
-export const baseSystemPromptSchema = {
-  type: "object",
-  additionalProperties: false,
-  properties: {
-    baseSystemPrompt: { type: "string" },
-    dndReplyProbability: { type: "number", minimum: 0, maximum: 1 },
-    startConversationCountThreshold: { type: "integer", minimum: 0, maximum: 10 },
-    startConversationTimeThreshold: {
-      type: "integer",
-      minimum: 30,
-      maximum: 720,
-    },
-  },
-  required: [
-    "baseSystemPrompt",
-    "dndReplyProbability",
-    "startConversationCountThreshold",
-    "startConversationTimeThreshold",
-  ],
-};
-
-export type BaseSystemPromptGeneration = {
-  baseSystemPrompt: string;
-  dndReplyProbability: number;
-  startConversationCountThreshold: number;
-  startConversationTimeThreshold: number;
-};