@tyvm/knowhow 0.0.104 → 0.0.106

package/src/clients/pricing/openrouter.ts

@@ -0,0 +1,36 @@
+/**
+ * OpenRouter pricing (USD per 1M tokens)
+ * Source: https://openrouter.ai/models
+ * Models with `:free` suffix are free. Others are paid.
+ * OpenRouter acts as an aggregator — prices may vary from original providers.
+ */
+export const OpenRouterTextPricing: Record<string, { input: number; output: number }> = {
+  // Free models (`:free` suffix)
+  "deepseek/deepseek-r1:free": { input: 0.0, output: 0.0 },
+  "deepseek/deepseek-chat-v3-0324:free": { input: 0.0, output: 0.0 },
+  "meta-llama/llama-3.3-70b-instruct:free": { input: 0.0, output: 0.0 },
+  "meta-llama/llama-4-maverick:free": { input: 0.0, output: 0.0 },
+  "meta-llama/llama-4-scout:free": { input: 0.0, output: 0.0 },
+  "google/gemma-3-27b-it:free": { input: 0.0, output: 0.0 },
+  "google/gemma-3-12b-it:free": { input: 0.0, output: 0.0 },
+  "microsoft/phi-4:free": { input: 0.0, output: 0.0 },
+  "qwen/qwen3-235b-a22b:free": { input: 0.0, output: 0.0 },
+  "qwen/qwen3-30b-a3b:free": { input: 0.0, output: 0.0 },
+  "mistralai/mistral-7b-instruct:free": { input: 0.0, output: 0.0 },
+  "nousresearch/hermes-3-llama-3.1-405b:free": { input: 0.0, output: 0.0 },
+  // Paid models (popular)
+  "openai/gpt-4o": { input: 2.5, output: 10.0 },
+  "openai/gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "anthropic/claude-3.5-sonnet": { input: 3.0, output: 15.0 },
+  "anthropic/claude-3-haiku": { input: 0.25, output: 1.25 },
+  // Source: openrouter.ai/api/v1/models (2026-04)
+  "deepseek/deepseek-r1": { input: 0.7, output: 2.5 },
+  "deepseek/deepseek-chat-v3-0324": { input: 0.2, output: 0.77 },
+  "meta-llama/llama-3.3-70b-instruct": { input: 0.12, output: 0.3 },
+  "google/gemini-2.0-flash-001": { input: 0.1, output: 0.4 },
+  // Source: openrouter.ai/api/v1/models (2026-04) — qwen3-235b-a22b = $0.455/$1.82
+  // Note: models.dev shows $0.15/$0.85 for dated variant, using OpenRouter live price
+  "qwen/qwen3-235b-a22b": { input: 0.455, output: 1.82 },
+  "qwen/qwen3-235b-a22b-07-25": { input: 0.15, output: 0.85 },
+  "mistralai/mistral-large-2411": { input: 2.0, output: 6.0 },
+};

package/src/clients/pricing/types.ts

@@ -0,0 +1,110 @@
+export type ModelType =
+  | "completion"
+  | "embedding"
+  | "image"
+  | "audio"
+  | "video"
+  | "transaction"
+  | "live";
+
+export interface ModelPricing {
+  input?: number;
+  output?: number;
+  cached_input?: number;
+  cache_write?: number;
+  cache_hit?: number;
+  input_audio?: number;
+  output_audio?: number;
+  input_gt_200k?: number;
+  output_gt_200k?: number;
+  image_generation?: number;
+  image_generation_per_1m_tokens?: number;
+  video_generation?: number;
+  output_image_per_1m_tokens?: number;
+  // Optional metadata — when set on a pricing entry, the catalog picks them up automatically
+  deprecated?: boolean;
+  deprecationDate?: string;
+  limitedAvailability?: boolean;
+  replacedBy?: string;
+  /** Supported reasoning effort levels for this model (ordered low→high). If set, effort will be clamped to these values. */
+  reasoningLevels?: string[];
+  /** If true, this model must be called via the Responses API (/v1/responses) instead of /v1/chat/completions */
+  useResponsesApi?: boolean;
+}
+
+export interface ModelCatalogEntry {
+  id: string;
+  provider: string;
+  type: ModelType;
+  pricing: ModelPricing;
+  deprecated?: boolean;
+  deprecationDate?: string;
+  /** Model exists but is not generally available (e.g. Live API only, limited access, or returns empty responses) */
+  limitedAvailability?: boolean;
+  /** Recommended replacement model ID when this model is deprecated */
+  replacedBy?: string;
+}
+
+// ─── Bulk catalog helpers ─────────────────────────────────────────────────────
+
+export interface DeprecationOptions {
+  deprecated?: boolean;
+  deprecationDate?: string;
+  limitedAvailability?: boolean;
+  replacedBy?: string;
+}
+
+function makeEntries(
+  type: ModelType,
+  ids: string[],
+  provider: string,
+  pricing: Record<string, ModelPricing>,
+  deprecation?: DeprecationOptions
+): ModelCatalogEntry[] {
+  return ids.map((id) => {
+    const p = pricing[id] ?? {};
+    // Explicit dep options take precedence; fall back to metadata embedded in the pricing entry
+    const deprecated       = deprecation?.deprecated       ?? p.deprecated;
+    const deprecationDate  = deprecation?.deprecationDate  ?? p.deprecationDate;
+    const limitedAvailability = deprecation?.limitedAvailability ?? p.limitedAvailability;
+    const replacedBy       = deprecation?.replacedBy       ?? p.replacedBy;
+    // Strip metadata fields before storing as pricing
+    const { deprecated: _d, deprecationDate: _dd, limitedAvailability: _la, replacedBy: _rb, reasoningLevels: _rl, useResponsesApi: _ura, ...pricingOnly } = p;
+    return {
+      id,
+      provider,
+      type,
+      pricing: { input: 0, output: 0, ...pricingOnly },
+      deprecated,
+      deprecationDate,
+      limitedAvailability,
+      replacedBy,
+    };
+  });
+}
+
+export const completions  = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("completion",   ids, provider, pricing, dep);
+export const embeddings   = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("embedding",    ids, provider, pricing, dep);
+export const images       = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("image",        ids, provider, pricing, dep);
+export const videos       = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("video",        ids, provider, pricing, dep);
+export const audios       = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("audio",        ids, provider, pricing, dep);
+export const transactions = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("transaction",  ids, provider, pricing, dep);
+export const liveApi      = (ids: string[], provider: string, pricing: Record<string, ModelPricing>, dep?: DeprecationOptions) => makeEntries("live",         ids, provider, pricing, dep);
+
+// ─── Single-entry helpers (for deprecated/special cases) ─────────────────────
+
+export function completion(
+  id: string,
+  provider: string,
+  pricing: Partial<ModelPricing> = {},
+  deprecation?: DeprecationOptions
+): ModelCatalogEntry {
+  return {
+    id, provider, type: "completion",
+    pricing: { input: 0, output: 0, ...pricing },
+    deprecated: deprecation?.deprecated,
+    deprecationDate: deprecation?.deprecationDate,
+    limitedAvailability: deprecation?.limitedAvailability,
+    replacedBy: deprecation?.replacedBy,
+  };
+}

package/src/clients/pricing/xai.ts

@@ -1,73 +1,130 @@
-import { Models } from "../../types";
+/**
+ * xAI model IDs, pricing, and catalog.
+ * Single source of truth for all xAI/Grok models.
+ */
+import { completions, images, videos, ModelCatalogEntry, ModelPricing } from "./types";
 
-export const XaiTextPricing = {
+// ─── Model IDs ────────────────────────────────────────────────────────────────
 
-  [Models.xai.Grok_4_20_Reasoning]: {
-    input: 2.0,
-    cache_hit: 0.20,
-    output: 6.0,
-  },
-  [Models.xai.Grok_4_20_NonReasoning]: {
-    input: 2.0,
-    cache_hit: 0.20,
-    output: 6.0,
-  },
-  [Models.xai.Grok4_1_Fast_NonReasoning]: {
-    input: 0.2,
-    cache_hit: 0.05,
-    output: 0.5,
-  },
-  [Models.xai.Grok4_1_Fast_Reasoning]: {
-    input: 0.2,
-    cache_hit: 0.05,
-    output: 0.5,
-  },
-  [Models.xai.GrokCodeFast]: {
-    input: 0.2,
-    cache_hit: 0.02,
-    output: 1.5,
-  },
-  [Models.xai.Grok4]: {
-    input: 3.0,
-    output: 15.0,
-  },
-  [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,
-  },
+export const XaiModels = {
+  Grok_4_20_Reasoning: "grok-4.20-0309-reasoning",
+  Grok_4_20_NonReasoning: "grok-4.20-0309-non-reasoning",
+  Grok_4_20_MultiAgent: "grok-4.20-multi-agent-0309",
+  Grok4_1_Fast_Reasoning: "grok-4-1-fast-reasoning",
+  Grok4_1_Fast_NonReasoning: "grok-4-1-fast-non-reasoning",
+  GrokCodeFast: "grok-code-fast-1",
+  Grok4: "grok-4-0709",
+  Grok3Beta: "grok-3-beta",
+  Grok3MiniBeta: "grok-3-mini-beta",
+  Grok3FastBeta: "grok-3-fast-beta",
+  Grok3MiniFastBeta: "grok-3-mini-fast-beta",
+  // Deprecated alias IDs used by models.dev (latest aliases and older beta names)
+  Grok2Latest: "grok-2-latest",
+  Grok2VisionLatest: "grok-2-vision-latest",
+  Grok3Latest: "grok-3-latest",
+  Grok3FastLatest: "grok-3-fast-latest",
+  Grok3MiniLatest: "grok-3-mini-latest",
+  Grok3MiniFastLatest: "grok-3-mini-fast-latest",
+  GrokBeta: "grok-beta",
+  GrokVisionBeta: "grok-vision-beta",
+  // grok-4-1-fast variants (aliases for grok-4-1-fast-reasoning/non-reasoning)
+  Grok4_1_Fast: "grok-4-1-fast",
+  Grok4Fast: "grok-4-fast",
+  Grok4FastNonReasoning: "grok-4-fast-non-reasoning",
+  Grok21212: "grok-2-1212",
+  Grok2Vision1212: "grok-2-vision-1212",
+  GrokImagineImage: "grok-imagine-image",
+  GrokImagineVideo: "grok-imagine-video",
+  Grok2Image1212: "grok-2-image-1212",
+} as const;
+
+// ─── Modality arrays ──────────────────────────────────────────────────────────
+
+export const XaiTextModels: string[] = [
+  XaiModels.Grok_4_20_Reasoning, XaiModels.Grok_4_20_NonReasoning,
+  XaiModels.Grok_4_20_MultiAgent,
+  XaiModels.Grok4_1_Fast_Reasoning, XaiModels.Grok4_1_Fast_NonReasoning,
+  XaiModels.GrokCodeFast, XaiModels.Grok4,
+  XaiModels.Grok3Beta, XaiModels.Grok3MiniBeta, XaiModels.Grok3FastBeta, XaiModels.Grok3MiniFastBeta,
+];
+
+// Models that require the Responses API (/v1/responses) instead of /v1/chat/completions
+// The xAI reasoning variants and multi-agent model use the Responses API
+export const XaiResponsesOnlyModels: string[] = [
+  XaiModels.Grok_4_20_Reasoning,
+  XaiModels.Grok_4_20_NonReasoning,
+  XaiModels.Grok_4_20_MultiAgent,
+  XaiModels.Grok4_1_Fast_Reasoning,
+  XaiModels.Grok4_1_Fast_NonReasoning,
+];
+
+// Models that support the reasoning_effort parameter
+// grok-3-mini variants support reasoning_effort; grok-3-beta, grok-4 etc. do NOT
+export const XaiReasoningModels: string[] = [
+  XaiModels.Grok_4_20_MultiAgent,
+  XaiModels.Grok3MiniBeta,
+  XaiModels.Grok3MiniFastBeta,
+];
+
+// Deprecated xAI models — "Model not found" (400) when called
+export const XaiDeprecatedTextModels: string[] = [
+  XaiModels.Grok21212, XaiModels.Grok2Vision1212,
+  // Alias IDs from models.dev that map to deprecated/versioned models
+  XaiModels.Grok2Latest, XaiModels.Grok2VisionLatest,
+  XaiModels.Grok3Latest, XaiModels.Grok3FastLatest,
+  XaiModels.Grok3MiniLatest, XaiModels.Grok3MiniFastLatest,
+  XaiModels.GrokBeta, XaiModels.GrokVisionBeta,
+  XaiModels.Grok4_1_Fast, XaiModels.Grok4Fast, XaiModels.Grok4FastNonReasoning,
+];
+export const XaiImageModels: string[] = [XaiModels.GrokImagineImage, XaiModels.Grok2Image1212];
+export const XaiVideoModels: string[] = [XaiModels.GrokImagineVideo];
+
+// ─── Pricing (USD per 1M tokens / per-image / per-second) ────────────────────
+
+export const XaiTextPricing: Record<string, ModelPricing> = {
+  [XaiModels.Grok_4_20_Reasoning]:       { input: 2.0, cache_hit: 0.20, output: 6.0, useResponsesApi: true },
+  [XaiModels.Grok_4_20_NonReasoning]:    { input: 2.0, cache_hit: 0.20, output: 6.0, useResponsesApi: true },
+  [XaiModels.Grok_4_20_MultiAgent]:      { input: 2.0, cache_hit: 0.20, output: 6.0, reasoningLevels: ["low", "medium", "high", "xhigh"], useResponsesApi: true },
+  [XaiModels.Grok4_1_Fast_Reasoning]:    { input: 0.2, cache_hit: 0.05, output: 0.5, useResponsesApi: true },
+  [XaiModels.Grok4_1_Fast_NonReasoning]: { input: 0.2, cache_hit: 0.05, output: 0.5, useResponsesApi: true },
+  [XaiModels.GrokCodeFast]:              { input: 0.2, cache_hit: 0.02, output: 1.5 },
+  [XaiModels.Grok4]:                     { input: 3.0, output: 15.0 },
+  [XaiModels.Grok3Beta]:                 { input: 3.0, output: 15.0 },
+  [XaiModels.Grok3MiniBeta]:             { input: 0.3, output: 0.5 },
+  [XaiModels.Grok3FastBeta]:             { input: 5.0, output: 25.0 },
+  [XaiModels.Grok3MiniFastBeta]:         { input: 0.6, output: 4.0 },
+  [XaiModels.Grok21212]:       { input: 2.0, output: 10.0, deprecated: true },
+  [XaiModels.Grok2Vision1212]: { input: 2.0, output: 10.0, deprecated: true },
+  // Deprecated alias IDs (models.dev uses these; they map to versioned/beta models above)
+  [XaiModels.Grok2Latest]:          { input: 2.0, output: 10.0, deprecated: true },
+  [XaiModels.Grok2VisionLatest]:    { input: 2.0, output: 10.0, deprecated: true },
+  [XaiModels.Grok3Latest]:          { input: 3.0, output: 15.0, deprecated: true },
+  [XaiModels.Grok3FastLatest]:      { input: 5.0, output: 25.0, deprecated: true },
+  [XaiModels.Grok3MiniLatest]:      { input: 0.3, output: 0.5,  deprecated: true },
+  [XaiModels.Grok3MiniFastLatest]:  { input: 0.6, output: 4.0,  deprecated: true },
+  [XaiModels.GrokBeta]:             { input: 5.0, output: 15.0, deprecated: true },
+  [XaiModels.GrokVisionBeta]:       { input: 5.0, output: 15.0, deprecated: true },
+  // grok-4-1-fast / grok-4-fast aliases — deprecated in favor of versioned reasoning/non-reasoning variants
+  [XaiModels.Grok4_1_Fast]:         { input: 0.2, output: 0.5, deprecated: true },
+  [XaiModels.Grok4Fast]:            { input: 0.2, output: 0.5, deprecated: true },
+  [XaiModels.Grok4FastNonReasoning]:{ input: 0.2, output: 0.5, deprecated: true },
 };
 
-// Image generation pricing: per image
-// Based on https://docs.x.ai/developers/models
-export const XaiImagePricing = {
-  "grok-imagine-image-pro": 0.07,
-  "grok-imagine-image": 0.02,
-  "grok-2-image-1212": 0.07,
+export const XaiImagePricing: Record<string, ModelPricing> = {
+  "grok-imagine-image-pro":        { image_generation: 0.07 },
+  [XaiModels.GrokImagineImage]:    { image_generation: 0.02 },
+  [XaiModels.Grok2Image1212]:      { image_generation: 0.07 },
 };
 
-// Video generation pricing: $0.05 per second
-// Based on https://docs.x.ai/developers/models
-export const XaiVideoPricing = {
-  "grok-imagine-video": 0.05, // per second
+export const XaiVideoPricing: Record<string, ModelPricing> = {
+  [XaiModels.GrokImagineVideo]: { video_generation: 0.05 },
 };
+
+// ─── Catalog ──────────────────────────────────────────────────────────────────
+// Metadata (deprecated, useResponsesApi) is read directly from XaiTextPricing entries.
+
+export const XAI_MODEL_CATALOG: ModelCatalogEntry[] = [
+  ...completions([...XaiTextModels, ...XaiDeprecatedTextModels], "xai", XaiTextPricing),
+  ...images(XaiImageModels, "xai", XaiImagePricing),
+  ...videos(XaiVideoModels, "xai", XaiVideoPricing),
+];

package/src/clients/types.ts

@@ -57,6 +57,10 @@ export interface CompletionOptions {
   tools?: Tool[];
   tool_choice?: "auto" | "none";
   max_tokens?: number;
+  /** Reasoning effort level for models that support it.
+   *  Maps to: OpenAI reasoning_effort, xAI reasoning.effort, Gemini thinkingLevel/thinkingBudget, Anthropic thinking budget.
+   *  "low" = minimal thinking, "medium" = balanced, "high" = maximum reasoning */
+  reasoning_effort?: "low" | "medium" | "high";
 }
 
 export interface CompletionResponse {

package/src/clients/xai.ts

@@ -29,6 +29,7 @@ import {
 
 import { Models, XaiImageModels, XaiVideoModels } from "../types";
 import { ModelModality } from "./types";
+import { XaiReasoningModels, XaiResponsesOnlyModels } from "./pricing/xai";
 
 export class GenericXAIClient implements GenericClient {
   private client: OpenAI;
@@ -54,6 +55,11 @@ export class GenericXAIClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    // Route to Responses API for models that require it
+    if (XaiResponsesOnlyModels.includes(options.model)) {
+      return this.createChatResponse(options);
+    }
+
     const xaiMessages = options.messages.map((msg) => {
       if (msg.role === "tool") {
         return {
@@ -70,6 +76,10 @@ export class GenericXAIClient implements GenericClient {
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
+      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && {
+        // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
+        reasoning_effort: options.reasoning_effort,
+      }),
       ...(options.tools && {
         tools: options.tools,
         tool_choice: "auto",
@@ -94,6 +104,146 @@ export class GenericXAIClient implements GenericClient {
     };
   }
 
+  /**
+   * Creates a completion using the xAI Responses API (/v1/responses).
+   * Used for grok-4.20 reasoning/non-reasoning and multi-agent models.
+   * Translates Chat Completions message format to Responses API format.
+   */
+  async createChatResponse(
+    options: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const apiKey = this.apiKey || process.env.XAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("XAI API key not set");
+    }
+
+    // Extract system messages as instructions
+    const systemMessages = options.messages.filter((m) => m.role === "system");
+    const nonSystemMessages = options.messages.filter((m) => m.role !== "system");
+    const instructions = systemMessages
+      .map((m) => (typeof m.content === "string" ? m.content : ""))
+      .join("\n")
+      .trim() || undefined;
+
+    // Convert chat messages to Responses API input items
+    const input: any[] = nonSystemMessages.map((msg) => {
+      if (msg.role === "tool") {
+        return {
+          type: "function_call_output",
+          call_id: msg.tool_call_id,
+          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+        };
+      }
+      if (msg.role === "assistant" && msg.tool_calls?.length) {
+        return msg.tool_calls.map((tc) => ({
+          type: "function_call",
+          id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
+          call_id: tc.id,
+          name: tc.function.name,
+          arguments: tc.function.arguments,
+        }));
+      }
+      return {
+        role: msg.role,
+        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+      };
+    }).flat();
+
+    // Convert tool definitions to Responses API format
+    const tools = options.tools?.map((tool) => ({
+      type: "function" as const,
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters as Record<string, unknown>,
+      strict: false,
+    }));
+
+    // Resolve reasoning effort, clamping to supported levels if defined in pricing
+    const pricing = XaiTextPricing[options.model];
+    const supportedLevels = pricing?.reasoningLevels;
+    let reasoningEffort: string | undefined = options.reasoning_effort;
+    if (supportedLevels?.length) {
+      if (!reasoningEffort || !supportedLevels.includes(reasoningEffort)) {
+        reasoningEffort = supportedLevels[0];
+      }
+    }
+
+    const body: any = {
+      model: options.model,
+      input,
+      ...(instructions && { instructions }),
+      ...(options.max_tokens && { max_output_tokens: Math.max(options.max_tokens, 16_000) }),
+      ...(reasoningEffort && { reasoning: { effort: reasoningEffort } }),
+      ...(tools?.length && { tools, tool_choice: "auto" }),
+      store: false,
+    };
+
+    const response = await fetch("https://api.x.ai/v1/responses", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`XAI Responses API error: ${response.status} ${errorText}`);
+    }
+
+    const data = await response.json();
+
+    // Map usage
+    const usage = data.usage
+      ? {
+          prompt_tokens: data.usage.input_tokens,
+          completion_tokens: data.usage.output_tokens,
+          total_tokens: data.usage.input_tokens + data.usage.output_tokens,
+        }
+      : undefined;
+
+    const usdCost = usage ? this.calculateCost(options.model, usage) : undefined;
+
+    // Collect text content and tool calls from output items
+    let textContent: string | null = null;
+    const toolCalls: any[] = [];
+
+    for (const item of data.output ?? []) {
+      if (item.type === "message") {
+        for (const part of item.content ?? []) {
+          if (part.type === "output_text") {
+            textContent = (textContent ?? "") + part.text;
+          }
+        }
+      } else if (item.type === "function_call") {
+        toolCalls.push({
+          id: item.call_id,
+          type: "function",
+          function: {
+            name: item.name,
+            arguments: item.arguments,
+          },
+        });
+      }
+    }
+
+    return {
+      choices: [
+        {
+          message: {
+            role: "assistant",
+            content: textContent,
+            ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+          },
+        },
+      ],
+      model: options.model,
+      usage,
+      usd_cost: usdCost,
+    };
+  }
+
   pricesPerMillion() {
     return XaiTextPricing;
   }
@@ -175,7 +325,7 @@ export class GenericXAIClient implements GenericClient {
     // Calculate cost based on model name
     const imageModel = options.model || "grok-imagine-image";
     const costPerImage =
-      XaiImagePricing[imageModel as keyof typeof XaiImagePricing] || 0.02;
+      XaiImagePricing[imageModel as keyof typeof XaiImagePricing]?.image_generation || 0.02;
     const usdCost = (options.n || 1) * costPerImage;
 
     return {
@@ -250,7 +400,7 @@ export class GenericXAIClient implements GenericClient {
     // Return immediately with the jobId – do NOT poll here.
     // Use getVideoStatus() to poll and downloadVideo() to fetch the result.
     const duration = options.duration || 5;
-    const pricePerSecond = XaiVideoPricing[model] || 0.07;
+    const pricePerSecond = XaiVideoPricing[model]?.video_generation || 0.07;
     const usdCost = duration * pricePerSecond;
 
     return {

package/src/fileSync.ts

@@ -265,8 +265,14 @@ export async function uploadDirectory(
   for (const relFile of localFiles) {
     const localFilePath = localDir + relFile;
     const remoteFilePath = remoteDir + relFile;
-    await uploadFile(client, s3Service, remoteFilePath, localFilePath, dryRun);
-    count++;
+    try {
+      await uploadFile(client, s3Service, remoteFilePath, localFilePath, dryRun);
+      count++;
+    } catch (error) {
+      console.error(
+        `   ❌ Failed to upload ${localFilePath}, skipping: ${error.message}`
+      );
+    }
   }
   return count;
 }

package/src/login.ts

@@ -29,7 +29,10 @@ export async function login(jwtFlag?: boolean): Promise<void> {
     // Use browser login as default method
     console.log("Starting browser-based authentication...");
     try {
-      const browserLoginService = new BrowserLoginService();
+      // Pass existing orgId from config (if any) so the browser pre-selects the right org
+      const existingConfig = await getConfig();
+      const existingOrgId = existingConfig?.orgId;
+      const browserLoginService = new BrowserLoginService(undefined, existingOrgId);
       await browserLoginService.login();
       console.log("Successfully authenticated via browser!");
     } catch (error) {
@@ -43,6 +46,7 @@ export async function login(jwtFlag?: boolean): Promise<void> {
   try {
     const storedJwt = await loadJwt();
     const { user, currentOrg } = await checkJwt(storedJwt);
+    const orgId = currentOrg?.organizationId;
 
     console.log(
       `Current user: ${user.email}, \nOrganization: ${currentOrg?.organization?.name} - ${currentOrg?.organization?.id}`
@@ -61,9 +65,13 @@ export async function login(jwtFlag?: boolean): Promise<void> {
       config.modelProviders.push({
         provider: "knowhow",
       });
-
-      await updateConfig(config);
     }
+    // Save orgId to config so sync:remote and other features use the correct org
+    if (orgId) {
+      config.orgId = orgId;
+    }
+
+    await updateConfig(config);
   } catch (error) {
     if (http.isHttpError(error) && error.response) {
       const errData = await error.response.json().catch(() => ({ message: "Unknown error" }));