nolo-cli 0.1.40 → 0.1.42

package/integrations/openai/models.ts

@@ -0,0 +1,271 @@
+// integrations/openai/models.ts
+import type { Model, ModelPrice } from "../../ai/llm/types";
+
+const scalePrice = (price: ModelPrice, multiplier: number): ModelPrice => ({
+  input: price.input * multiplier,
+  output: price.output * multiplier,
+  ...(typeof price.cachingWrite === "number"
+    ? { cachingWrite: price.cachingWrite * multiplier }
+    : {}),
+  ...(typeof price.cachingRead === "number"
+    ? { cachingRead: price.cachingRead * multiplier }
+    : {}),
+  ...(typeof price.inputCacheHit === "number"
+    ? { inputCacheHit: price.inputCacheHit * multiplier }
+    : {}),
+});
+
+const GPT_5_4_STANDARD_PRICE: ModelPrice = {
+  input: 2.5 * 8,
+  output: 15 * 8,
+  inputCacheHit: 0.25 * 8,
+};
+
+const GPT_5_5_STANDARD_PRICE: ModelPrice = {
+  input: 5 * 8,
+  output: 30 * 8,
+  inputCacheHit: 0.5 * 8,
+};
+
+const GPT_5_4_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 5 * 8,
+  output: 22.5 * 8,
+  inputCacheHit: 0.5 * 8,
+};
+
+const GPT_5_5_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 10 * 8,
+  output: 45 * 8,
+  inputCacheHit: 1 * 8,
+};
+
+const GPT_5_4_PRO_STANDARD_PRICE: ModelPrice = {
+  input: 30 * 8,
+  output: 180 * 8,
+  inputCacheHit: 0,
+};
+
+const GPT_5_4_PRO_LONG_CONTEXT_PRICE: ModelPrice = {
+  input: 60 * 8,
+  output: 270 * 8,
+  inputCacheHit: 0,
+};
+
+export const openAIModels: Model[] = [
+  {
+    name: "gpt-5.5",
+    displayName: "GPT-5.5 Standard",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_5_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_5_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.5-flex",
+    displayName: "GPT-5.5 Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_5_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_5_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.5-pro",
+    displayName: "GPT-5.5 Pro",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_4_PRO_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_4_PRO_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.5-pro-flex",
+    displayName: "GPT-5.5 Pro Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_4_PRO_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_4_PRO_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-image-2",
+    displayName: "GPT Image 2",
+    endpointKey: "responses",
+    hasVision: true,
+    hasImageOutput: true,
+    supportsImageOutput: true,
+    supportsTool: false,
+    contextWindow: 128_000,
+    maxOutputTokens: 32_768,
+    // OpenAI's current public pricing page does not list GPT Image 2 separately.
+    // Reuse GPT Image 1.5 pricing as a conservative placeholder until official
+    // GPT Image 2 pricing is published.
+    price: { input: 5 * 8, output: 10 * 8, inputCacheHit: 1.25 * 8 },
+    pricePerImage: 0.04 * 8,
+  },
+  {
+    name: "gpt-5.4",
+    displayName: "GPT-5.4 Standard",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_4_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_4_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.4-flex",
+    displayName: "GPT-5.4 Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_4_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_4_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.4-mini",
+    displayName: "GPT-5.4 Mini",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 0.75 * 8, output: 4.5 * 8, inputCacheHit: 0.075 * 8 },
+  },
+  {
+    name: "gpt-5.4-nano",
+    displayName: "GPT-5.4 Nano",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 0.2 * 8, output: 1.25 * 8, inputCacheHit: 0.02 * 8 },
+  },
+  {
+    name: "gpt-5.4-pro",
+    displayName: "GPT-5.4 Pro",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: GPT_5_4_PRO_STANDARD_PRICE,
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: GPT_5_4_PRO_LONG_CONTEXT_PRICE,
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5.4-pro-flex",
+    displayName: "GPT-5.4 Pro Flex",
+    endpointKey: "responses",
+    hasVision: true,
+    contextWindow: 1_047_576,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: scalePrice(GPT_5_4_PRO_STANDARD_PRICE, 0.5),
+    pricingStrategy: {
+      type: "tiered_context",
+      tiers: [
+        {
+          minContext: 272_001,
+          price: scalePrice(GPT_5_4_PRO_LONG_CONTEXT_PRICE, 0.5),
+        },
+      ],
+    },
+  },
+  {
+    name: "gpt-5",
+    displayName: "GPT-5",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 1.25 * 8, output: 10 * 8, inputCacheHit: 0.125 * 8 },
+  },
+  {
+    name: "gpt-5-mini",
+    displayName: "GPT-5 mini",
+    hasVision: true,
+    contextWindow: 400_000,
+    maxOutputTokens: 128_000,
+    supportsReasoningEffort: true,
+    price: { input: 0.25 * 8, output: 2 * 8, inputCacheHit: 0.025 * 8 },
+  },
+  {
+    name: "o3-pro",
+    displayName: "O3 Pro",
+    hasVision: false,
+    contextWindow: 200_000,
+    maxOutputTokens: 100_000,
+    supportsReasoningEffort: true,
+    endpointKey: "responses",
+    price: { input: 20 * 7, output: 80 * 7, inputCacheHit: 0 },
+  },
+];

package/integrations/openai/providerBodyCompatibility.ts

@@ -0,0 +1,23 @@
+import { isFireworksKimiModel } from "../../ai/llm/kimi";
+
+type NormalizeChatCompletionsBodyArgs = {
+  body: Record<string, any>;
+  provider: string;
+  model: string;
+};
+
+export const normalizeChatCompletionsBodyForProvider = ({
+  body,
+  provider,
+  model,
+}: NormalizeChatCompletionsBodyArgs): Record<string, any> => {
+  const nextBody = { ...body, model };
+  const normalizedProvider = provider.trim().toLowerCase();
+
+  if (normalizedProvider === "fireworks" && isFireworksKimiModel(model)) {
+    delete nextBody.reasoning;
+    delete nextBody.reasoning_effort;
+  }
+
+  return nextBody;
+};

package/integrations/openai/responsesHelpers.ts

@@ -0,0 +1,297 @@
+import type { Message } from "../../app/types";
+
+type MessageContentPart =
+  | { type: "text"; text: string }
+  | { type: "image_url"; image_url: { url: string; detail?: "low" | "high" | "auto" } };
+
+type ToolCall = {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+};
+
+type ResponseInputTextPart =
+  | { type: "input_text"; text: string }
+  | { type: "output_text"; text: string };
+type ResponseInputImagePart = {
+  type: "input_image";
+  image_url: string;
+  detail?: "low" | "high" | "auto";
+};
+
+type ResponseInputMessage = {
+  type: "message";
+  role: "system" | "developer" | "user" | "assistant";
+  content: Array<ResponseInputTextPart | ResponseInputImagePart>;
+};
+
+type ResponseFunctionCall = {
+  type: "function_call";
+  call_id: string;
+  name: string;
+  arguments: string;
+};
+
+type ResponseFunctionCallOutput = {
+  type: "function_call_output";
+  call_id: string;
+  output: string;
+};
+
+export type ResponseInputItem =
+  | ResponseInputMessage
+  | ResponseFunctionCall
+  | ResponseFunctionCallOutput;
+
+export type AssistantToolCall = ToolCall;
+
+const RESPONSES_TOP_LEVEL_SCHEMA_KEYS = ["anyOf", "oneOf", "allOf", "enum", "not"] as const;
+
+const sanitizeResponsesParameters = (parameters: any): any => {
+  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) {
+    return parameters;
+  }
+
+  const next = { ...parameters };
+  for (const key of RESPONSES_TOP_LEVEL_SCHEMA_KEYS) {
+    delete next[key];
+  }
+  return next;
+};
+
+const appendTextPart = (
+  parts: Array<ResponseInputTextPart | ResponseInputImagePart>,
+  text: string,
+  role: "system" | "developer" | "user" | "assistant"
+) => {
+  if (!text) return;
+  const last = parts.at(-1);
+  const textType = role === "assistant" ? "output_text" : "input_text";
+  if (last?.type === textType) {
+    last.text += text;
+    return;
+  }
+  parts.push({ type: textType, text });
+};
+
+const normalizeMessageParts = (
+  content: Message["content"],
+  role: "system" | "developer" | "user" | "assistant"
+): Array<ResponseInputTextPart | ResponseInputImagePart> => {
+  if (typeof content === "string") {
+    if (!content) return [];
+    return [
+      {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text: content,
+      },
+    ];
+  }
+
+  const parts: Array<ResponseInputTextPart | ResponseInputImagePart> = [];
+  for (const part of content ?? []) {
+    const typedPart = part as MessageContentPart;
+    if (typedPart?.type === "text" && typeof typedPart.text === "string") {
+      appendTextPart(parts, typedPart.text, role);
+      continue;
+    }
+
+    if (
+      typedPart?.type === "image_url" &&
+      typeof typedPart.image_url?.url === "string" &&
+      typedPart.image_url.url
+    ) {
+      if (role === "assistant") continue;
+      parts.push({
+        type: "input_image",
+        image_url: typedPart.image_url.url,
+        detail: typedPart.image_url.detail,
+      });
+    }
+  }
+
+  return parts;
+};
+
+const normalizeToolOutput = (content: Message["content"]): string => {
+  if (typeof content === "string") return content;
+  return JSON.stringify(content ?? "");
+};
+
+export const toResponsesTools = (tools: any[] | undefined): any[] | undefined => {
+  if (!Array.isArray(tools) || tools.length === 0) return undefined;
+
+  return tools
+    .map((tool) => {
+      const fn = tool?.function;
+      if (!fn?.name) return null;
+      return {
+        type: "function",
+        name: fn.name,
+        description: fn.description,
+        parameters: sanitizeResponsesParameters(fn.parameters),
+        strict: fn.strict,
+      };
+    })
+    .filter(Boolean);
+};
+
+export const convertMessagesToResponsesInput = (
+  messages: Array<Pick<Message, "role" | "content" | "tool_calls" | "tool_call_id">>
+): ResponseInputItem[] => {
+  const input: ResponseInputItem[] = [];
+
+  for (const message of messages) {
+    if (!message?.role) continue;
+
+    if (message.role === "tool") {
+      if (!message.tool_call_id) continue;
+      input.push({
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: normalizeToolOutput(message.content),
+      });
+      continue;
+    }
+
+    const role = message.role as ResponseInputMessage["role"];
+    const contentParts = normalizeMessageParts(message.content, role);
+    if (contentParts.length > 0) {
+      input.push({
+        type: "message",
+        role,
+        content: contentParts,
+      });
+    }
+
+    if (role === "assistant" && Array.isArray(message.content)) {
+      const replayImages = message.content
+        .map((part) => part as MessageContentPart)
+        .filter(
+          (part) =>
+            part?.type === "image_url" &&
+            typeof part.image_url?.url === "string" &&
+            part.image_url.url
+        )
+        .map((part) => ({
+          type: "input_image" as const,
+          image_url: part.image_url.url,
+          detail: part.image_url.detail,
+        }));
+
+      if (replayImages.length > 0) {
+        input.push({
+          type: "message",
+          role: "user",
+          content: replayImages,
+        });
+      }
+    }
+
+    if (role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const toolCall of message.tool_calls as ToolCall[]) {
+        if (!toolCall?.id || !toolCall.function?.name) continue;
+        input.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments:
+            typeof toolCall.function.arguments === "string"
+              ? toolCall.function.arguments
+              : JSON.stringify(toolCall.function.arguments ?? {}),
+        });
+      }
+    }
+  }
+
+  return input;
+};
+
+export const extractTextFromResponseOutput = (response: any): string => {
+  const parts: string[] = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+};
+
+const toDataUrl = (base64Data: string, mimeType?: string | null): string => {
+  const normalizedMimeType =
+    typeof mimeType === "string" && mimeType.trim()
+      ? mimeType.trim()
+      : "image/png";
+  return `data:${normalizedMimeType};base64,${base64Data}`;
+};
+
+export const extractImagePartsFromResponseOutput = (
+  response: any
+): Array<{ type: "image_url"; image_url: { url: string } }> => {
+  const images: Array<{ type: "image_url"; image_url: { url: string } }> = [];
+
+  for (const item of response?.output ?? []) {
+    if (item?.type === "image_generation_call") {
+      if (typeof item.result === "string" && item.result.trim()) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              item.result.trim(),
+              typeof item.output_format === "string" && item.output_format.trim()
+                ? `image/${item.output_format.trim()}`
+                : undefined
+            ),
+          },
+        });
+      }
+      continue;
+    }
+
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (
+        content?.type === "output_image" &&
+        typeof content.result === "string" &&
+        content.result.trim()
+      ) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              content.result.trim(),
+              content.mime_type ?? content.mimeType ?? null
+            ),
+          },
+        });
+      }
+    }
+  }
+
+  return images;
+};
+
+export const extractToolCallsFromResponseOutput = (
+  response: any
+): AssistantToolCall[] => {
+  const calls: AssistantToolCall[] = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "function_call") continue;
+    if (!item.call_id || !item.name) continue;
+    calls.push({
+      id: item.call_id,
+      type: "function",
+      function: {
+        name: item.name,
+        arguments:
+          typeof item.arguments === "string"
+            ? item.arguments
+            : JSON.stringify(item.arguments ?? {}),
+      },
+    });
+  }
+  return calls;
+};

package/integrations/x-reader/types.ts

@@ -0,0 +1,109 @@
+export type XBackendName =
+  | "desktop_local_browser"
+  | "extension_bridge"
+  | "oauth_api"
+  | "opencli"
+  | "public_fallback"
+  | "fixture";
+
+export type XReadFailureCode =
+  | "not_connected"
+  | "not_logged_in"
+  | "not_found"
+  | "restricted"
+  | "suspended_or_deleted"
+  | "rate_limited"
+  | "network_error"
+  | "parse_error"
+  | "unsupported_content"
+  | "cancelled"
+  | "unknown";
+
+export type XAuthor = {
+  id?: string;
+  handle: string;
+  displayName?: string;
+  verified?: boolean;
+  profileUrl?: string;
+};
+
+export type XMedia = {
+  type: "image" | "video" | "gif" | "unknown";
+  url?: string;
+  previewUrl?: string;
+  altText?: string;
+};
+
+export type XPostSummary = {
+  id?: string;
+  url?: string;
+  authorHandle?: string;
+  text?: string;
+};
+
+export type XPost = {
+  id: string;
+  url: string;
+  author: XAuthor;
+  text: string;
+  createdAt?: string;
+  media: XMedia[];
+  quotedPost?: XPostSummary;
+  replyTo?: XPostSummary;
+  metrics?: {
+    replies?: number;
+    reposts?: number;
+    likes?: number;
+    views?: number;
+  };
+  sourceBackend: XBackendName;
+  fetchedAt: string;
+};
+
+export type XThread = {
+  root: XPost;
+  posts: XPost[];
+  completeness: "complete" | "partial" | "single_post" | "unknown";
+  missingReason?: XReadFailureCode;
+};
+
+export type XReadFailure = {
+  ok: false;
+  code: XReadFailureCode;
+  message: string;
+  nextStep?: string;
+  backend: XBackendName;
+  fetchedAt: string;
+};
+
+export type XReadSuccess<T> = {
+  ok: true;
+  backend: XBackendName;
+  fetchedAt: string;
+  data: T;
+};
+
+export type XReadResult<T> = XReadSuccess<T> | XReadFailure;
+
+export type XReaderBackend = {
+  name: XBackendName;
+  readPost(url: string): Promise<XReadResult<XPost>>;
+  readThread(url: string): Promise<XReadResult<XThread>>;
+};
+
+export function createXReadFailure(args: {
+  code: XReadFailureCode;
+  message: string;
+  nextStep?: string;
+  backend: XBackendName;
+  fetchedAt?: string;
+}): XReadFailure {
+  return {
+    ok: false,
+    code: args.code,
+    message: args.message,
+    nextStep: args.nextStep,
+    backend: args.backend,
+    fetchedAt: args.fetchedAt ?? new Date().toISOString(),
+  };
+}

package/integrations/xai/models.ts

@@ -0,0 +1,13 @@
+import { Model } from "../../ai/llm/types";
+
+export const xaiModels: Model[] = [
+  {
+    name: "grok-4-0709",
+    displayName: "Grok4 0709",
+    hasVision: false,
+    contextWindow: 131072,
+    price: { input: 3 * 7, output: 15 * 7 }, // $3/$15 per MTok × 7
+    fnCall: true,
+    jsonOutput: true,
+  },
+];