@steipete/summarize 0.11.1 → 0.13.0

package/dist/types/daemon/agent-request.d.ts

@@ -0,0 +1,14 @@
+import type { Message, Tool } from "@mariozechner/pi-ai";
+export declare function getAgentPrompt(automationEnabled: boolean): string;
+export declare function buildSystemPrompt({ pageUrl, pageTitle, pageContent, automationEnabled, }: {
+    pageUrl: string;
+    pageTitle: string | null;
+    pageContent: string;
+    automationEnabled: boolean;
+}): string;
+export declare function flattenAgentForCli({ systemPrompt, messages, }: {
+    systemPrompt: string;
+    messages: Message[];
+}): string;
+export declare function normalizeMessages(raw: unknown): Message[];
+export declare function resolveToolList(automationEnabled: boolean, tools: string[], definitions: Record<string, Tool>): Tool[];

package/dist/types/daemon/chat.d.ts

@@ -1,4 +1,5 @@
 import type { Message } from "@mariozechner/pi-ai";
+import type { SummarizeConfig } from "../config.js";
 type ChatSession = {
     id: string;
     lastMeta: {
@@ -12,9 +13,10 @@ type ChatEvent = {
     event: string;
     data?: unknown;
 };
-export declare function streamChatResponse({ env, fetchImpl, session: _session, pageUrl, pageTitle, pageContent, messages, modelOverride, pushToSession, emitMeta, }: {
+export declare function streamChatResponse({ env, fetchImpl, configForCli, session: _session, pageUrl, pageTitle, pageContent, messages, modelOverride, pushToSession, emitMeta, }: {
     env: Record<string, string | undefined>;
     fetchImpl: typeof fetch;
+    configForCli?: SummarizeConfig | null;
     session: ChatSession;
     pageUrl: string;
     pageTitle: string | null;

package/dist/types/daemon/config.d.ts

@@ -6,14 +6,25 @@ export type DaemonConfigV1 = {
     env: EnvSnapshot;
     installedAt: string;
 };
-export type DaemonConfig = DaemonConfigV1;
+export type DaemonConfigV2 = {
+    version: 2;
+    token: string;
+    tokens: string[];
+    port: number;
+    env: EnvSnapshot;
+    installedAt: string;
+};
+export type DaemonConfig = DaemonConfigV1 | DaemonConfigV2;
 export declare function resolveDaemonConfigPath(env: Record<string, string | undefined>): string;
 export declare function normalizeDaemonToken(raw: string): string;
+export declare function normalizeDaemonTokens(raw: unknown): string[];
+export declare function daemonConfigPrimaryToken(config: DaemonConfig): string;
+export declare function daemonConfigTokens(config: DaemonConfig): string[];
 export declare function normalizeDaemonPort(raw: unknown): number;
 export declare function readDaemonConfig({ env, }: {
     env: Record<string, string | undefined>;
 }): Promise<DaemonConfig | null>;
 export declare function writeDaemonConfig({ env, config, }: {
     env: Record<string, string | undefined>;
-    config: Omit<DaemonConfig, "version" | "installedAt"> & Partial<Pick<DaemonConfig, "installedAt">>;
+    config: Omit<DaemonConfigV2, "version" | "installedAt"> & Partial<Pick<DaemonConfigV2, "installedAt">>;
 }): Promise<string>;

package/dist/types/daemon/env-snapshot.d.ts

@@ -1,4 +1,4 @@
-declare const ENV_KEYS: readonly ["PATH", "XAI_API_KEY", "XAI_BASE_URL", "OPENAI_API_KEY", "OPENAI_WHISPER_BASE_URL", "OPENAI_BASE_URL", "OPENROUTER_API_KEY", "OPENAI_USE_CHAT_COMPLETIONS", "Z_AI_API_KEY", "ZAI_API_KEY", "Z_AI_BASE_URL", "ZAI_BASE_URL", "GEMINI_API_KEY", "GOOGLE_BASE_URL", "GEMINI_BASE_URL", "GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY", "ANTHROPIC_API_KEY", "ANTHROPIC_BASE_URL", "FIRECRAWL_API_KEY", "APIFY_API_TOKEN", "YT_DLP_PATH", "SUMMARIZE_YT_DLP_COOKIES_FROM_BROWSER", "YT_DLP_COOKIES_FROM_BROWSER", "FAL_KEY", "GROQ_API_KEY", "SUMMARIZE_MODEL", "SUMMARIZE_TRANSCRIBER", "SUMMARIZE_ONNX_PARAKEET_CMD", "SUMMARIZE_ONNX_CANARY_CMD", "CLAUDE_PATH", "CODEX_PATH", "GEMINI_PATH", "AGENT_PATH", "UVX_PATH"];
+declare const ENV_KEYS: readonly ["PATH", "XAI_API_KEY", "XAI_BASE_URL", "OPENAI_API_KEY", "OPENAI_WHISPER_BASE_URL", "OPENAI_BASE_URL", "OPENROUTER_API_KEY", "OPENAI_USE_CHAT_COMPLETIONS", "NVIDIA_API_KEY", "NGC_API_KEY", "NVIDIA_BASE_URL", "Z_AI_API_KEY", "ZAI_API_KEY", "Z_AI_BASE_URL", "ZAI_BASE_URL", "GEMINI_API_KEY", "GOOGLE_BASE_URL", "GEMINI_BASE_URL", "GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY", "ANTHROPIC_API_KEY", "ANTHROPIC_BASE_URL", "FIRECRAWL_API_KEY", "APIFY_API_TOKEN", "YT_DLP_PATH", "SUMMARIZE_YT_DLP_COOKIES_FROM_BROWSER", "YT_DLP_COOKIES_FROM_BROWSER", "FAL_KEY", "GROQ_API_KEY", "ASSEMBLYAI_API_KEY", "SUMMARIZE_MODEL", "SUMMARIZE_TRANSCRIBER", "SUMMARIZE_ONNX_PARAKEET_CMD", "SUMMARIZE_ONNX_CANARY_CMD", "CLAUDE_PATH", "CODEX_PATH", "GEMINI_PATH", "AGENT_PATH", "OPENCLAW_PATH", "OPENCODE_PATH", "UVX_PATH"];
 export type EnvSnapshot = Partial<Record<(typeof ENV_KEYS)[number], string>>;
 export declare function buildEnvSnapshotFromEnv(env: Record<string, string | undefined>): EnvSnapshot;
 export {};

package/dist/types/daemon/flow-context.d.ts

@@ -1,8 +1,8 @@
 import type { CacheState } from "../cache.js";
 import type { ExtractedLinkContent, LinkPreviewProgressEvent, MediaCache } from "../content/index.js";
-import type { UrlFlowContext } from "../run/flows/url/types.js";
-import type { SlideImage, SlideSettings, SlideSourceKind } from "../slides/index.js";
+import { type UrlFlowContext } from "../run/flows/url/types.js";
 import { type RunOverrides } from "../run/run-settings.js";
+import type { SlideImage, SlideSettings, SlideSourceKind } from "../slides/index.js";
 type TextSink = {
     writeChunk: (text: string) => void;
 };

package/dist/types/daemon/models.d.ts

@@ -14,6 +14,7 @@ export declare function buildModelPickerOptions({ env, envForRun, configForCli,
     providers: {
         xai: boolean;
         openai: boolean;
+        nvidia: boolean;
         google: boolean;
         anthropic: boolean;
         openrouter: boolean;
@@ -22,6 +23,8 @@ export declare function buildModelPickerOptions({ env, envForRun, configForCli,
         cliGemini: boolean;
         cliCodex: boolean;
         cliAgent: boolean;
+        cliOpenclaw: boolean;
+        cliOpencode: boolean;
     };
     openaiBaseUrl: string | null;
     localModelsSource: {

package/dist/types/daemon/schtasks.d.ts

@@ -14,7 +14,8 @@ export declare function uninstallScheduledTask({ env, stdout, }: {
     env: Record<string, string | undefined>;
     stdout: NodeJS.WritableStream;
 }): Promise<void>;
-export declare function restartScheduledTask({ stdout, }: {
+export declare function restartScheduledTask({ env, stdout, }: {
+    env: Record<string, string | undefined>;
     stdout: NodeJS.WritableStream;
 }): Promise<void>;
 export declare function isScheduledTaskInstalled(): Promise<boolean>;

package/dist/types/daemon/server-admin-routes.d.ts

@@ -0,0 +1,22 @@
+import http from "node:http";
+import type { SummarizeConfig } from "../config.js";
+import type { DaemonLogger } from "../logging/daemon.js";
+import { type ProcessRegistry } from "./process-registry.js";
+export declare function handleAdminRoutes({ req, res, url, pathname, cors, env, fetchImpl, summarizeConfig, daemonLogger, daemonLogFile, daemonLogPaths, processRegistry, resolveToolPath, }: {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    url: URL;
+    pathname: string;
+    cors: Record<string, string>;
+    env: Record<string, string | undefined>;
+    fetchImpl: typeof fetch;
+    summarizeConfig: SummarizeConfig | null;
+    daemonLogger: DaemonLogger;
+    daemonLogFile: string;
+    daemonLogPaths: {
+        stdoutPath: string;
+        stderrPath: string;
+    };
+    processRegistry: ProcessRegistry;
+    resolveToolPath: (binary: string, env: Record<string, string | undefined>, explicitEnvKey?: string) => string | null;
+}): Promise<boolean>;

package/dist/types/daemon/server-agent-route.d.ts

@@ -0,0 +1,9 @@
+import type http from "node:http";
+export declare function handleAgentRoute({ req, res, url, cors, env, createRunId, }: {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    url: URL;
+    cors: Record<string, string>;
+    env: Record<string, string | undefined>;
+    createRunId: () => string;
+}): Promise<boolean>;

package/dist/types/daemon/server-http.d.ts

@@ -0,0 +1,10 @@
+import http from "node:http";
+export declare function json(res: http.ServerResponse, status: number, payload: unknown, headers?: Record<string, string>): void;
+export declare function text(res: http.ServerResponse, status: number, body: string, headers?: Record<string, string>): void;
+export declare function clampNumber(value: number, min: number, max: number): number;
+export declare function isTrustedOrigin(origin: string): boolean;
+export declare function corsHeaders(origin: string | null): Record<string, string>;
+export declare function readCorsHeaders(req: http.IncomingMessage): Record<string, string>;
+export declare function readBearerToken(req: http.IncomingMessage): string | null;
+export declare function readJsonBody(req: http.IncomingMessage, maxBytes: number): Promise<unknown>;
+export declare function wantsJsonResponse(req: http.IncomingMessage, url: URL): boolean;

package/dist/types/daemon/server-session-routes.d.ts

@@ -0,0 +1,11 @@
+import type { Session } from "./server-session.js";
+export declare function handleSessionRoutes(options: {
+    req: import("node:http").IncomingMessage;
+    res: import("node:http").ServerResponse<import("node:http").IncomingMessage>;
+    pathname: string;
+    cors: Record<string, string>;
+    env: Record<string, string | undefined>;
+    port: number;
+    sessions: Map<string, Session>;
+    refreshSessions: Map<string, Session>;
+}): Promise<boolean>;

package/dist/types/daemon/server-session.d.ts

@@ -0,0 +1,52 @@
+import http from "node:http";
+import { type SseEvent, type SseSlidesData } from "../shared/sse-events.js";
+import type { SlideExtractionResult } from "../slides/index.js";
+export type SessionEvent = SseEvent;
+export type Session = {
+    id: string;
+    createdAtMs: number;
+    buffer: Array<{
+        event: SessionEvent;
+        bytes: number;
+    }>;
+    bufferBytes: number;
+    done: boolean;
+    clients: Set<http.ServerResponse>;
+    slidesBuffer: Array<{
+        event: SessionEvent;
+        bytes: number;
+    }>;
+    slidesBufferBytes: number;
+    slidesClients: Set<http.ServerResponse>;
+    slidesDone: boolean;
+    slidesRequested: boolean;
+    slidesLastStatus: string | null;
+    lastMeta: {
+        model: string | null;
+        modelLabel: string | null;
+        inputSummary: string | null;
+        summaryFromCache: boolean | null;
+    };
+    slides: SlideExtractionResult | null;
+};
+export declare function createSession(idFactory: () => string): Session;
+export declare function pushToSession(session: Session, event: SessionEvent, onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null): void;
+export declare function pushSlidesToSession(session: Session, event: SessionEvent, onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null): void;
+export declare function emitMeta(session: Session, data: {
+    model?: string | null;
+    modelLabel?: string | null;
+    inputSummary?: string | null;
+    summaryFromCache?: boolean | null;
+}, onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null): void;
+export declare function emitSlides(session: Session, data: SseSlidesData, onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null): void;
+export declare function emitSlidesStatus(session: Session, text: string, onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null): void;
+export declare function emitSlidesDone(session: Session, result: {
+    ok: boolean;
+    error?: string | null;
+}, onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null): void;
+export declare function endSession(session: Session): void;
+export declare function scheduleSessionCleanup({ sessions, refreshSessions, session, }: {
+    sessions: Map<string, Session>;
+    refreshSessions: Map<string, Session>;
+    session: Session;
+}): void;

package/dist/types/daemon/server-sse.d.ts

@@ -0,0 +1,12 @@
+import http from "node:http";
+import { type SseEvent } from "../shared/sse-events.js";
+export declare function attachBufferedSseSession({ res, cors, buffer, clients, done, afterReplay, }: {
+    res: http.ServerResponse;
+    cors: Record<string, string>;
+    buffer: Array<{
+        event: SseEvent;
+    }>;
+    clients: Set<http.ServerResponse>;
+    done: boolean;
+    afterReplay?: (() => void) | null;
+}): void;

package/dist/types/daemon/server-summarize-execution.d.ts

@@ -0,0 +1,70 @@
+import type { CacheState } from "../cache.js";
+import type { MediaCache } from "../content/index.js";
+import { type SseSlidesData } from "../shared/sse-events.js";
+import type { SlideExtractionResult } from "../slides/index.js";
+import { type Session, type SessionEvent } from "./server-session.js";
+import type { ParsedSummarizeRequest } from "./server-summarize-request.js";
+import { extractContentForUrl } from "./summarize.js";
+type LoggerLike = {
+    info?: (payload: Record<string, unknown>) => void;
+    error?: (payload: Record<string, unknown>) => void;
+};
+type SlidesLogShape = {
+    enabled: boolean;
+    ocr: boolean;
+    outputDir: string;
+    sceneThreshold: number | null;
+    autoTuneThreshold: boolean;
+    maxSlides: number | null;
+    minDurationSeconds: number | null;
+};
+type ExecuteSummarizeSessionArgs = {
+    session: Session;
+    request: ParsedSummarizeRequest;
+    env: Record<string, string | undefined>;
+    fetchImpl: typeof fetch;
+    cacheState: CacheState;
+    mediaCache: MediaCache | null;
+    port: number;
+    onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null;
+    requestLogger?: LoggerLike | null;
+    includeContentLog: boolean;
+    logStartedAt: number;
+    logInput: {
+        url: string;
+        title: string | null;
+        text: string | null;
+        truncated: boolean | null;
+    } | null;
+    logSlidesSettings: SlidesLogShape | null;
+    sessions: Map<string, Session>;
+    refreshSessions: Map<string, Session>;
+};
+export declare function buildSlidesPayload({ slides, port, }: {
+    slides: SlideExtractionResult;
+    port: number;
+}): SseSlidesData;
+export declare function handleExtractOnlySummarizeRequest({ request, env, fetchImpl, cacheState, mediaCache, }: {
+    request: ParsedSummarizeRequest;
+    env: Record<string, string | undefined>;
+    fetchImpl: typeof fetch;
+    cacheState: CacheState;
+    mediaCache: MediaCache | null;
+}): Promise<{
+    extracted: Awaited<ReturnType<typeof extractContentForUrl>>["extracted"];
+    slides: Awaited<ReturnType<typeof extractContentForUrl>>["slides"];
+}>;
+export declare function toExtractOnlySlidesPayload(slides: SlideExtractionResult | null): {
+    sourceUrl: string;
+    sourceId: string;
+    sourceKind: string;
+    ocrAvailable: boolean;
+    slides: Array<{
+        index: number;
+        timestamp: number;
+        ocrText?: string | null;
+        ocrConfidence?: number | null;
+    }>;
+} | null;
+export declare function executeSummarizeSession({ session, request, env, fetchImpl, cacheState, mediaCache, port, onSessionEvent, requestLogger, includeContentLog, logStartedAt, logInput, logSlidesSettings, sessions, refreshSessions, }: ExecuteSummarizeSessionArgs): Promise<void>;
+export {};

package/dist/types/daemon/server-summarize-request.d.ts

@@ -0,0 +1,36 @@
+import type http from "node:http";
+import { resolveRunOverrides } from "../run/run-settings.js";
+import type { SlideSettings } from "../slides/index.js";
+import type { DaemonRequestedMode } from "./auto-mode.js";
+export declare function parseDiagnostics(raw: unknown): {
+    includeContent: boolean;
+};
+export declare function resolveHomeDir(env: Record<string, string | undefined>): string;
+export type ParsedSummarizeRequest = {
+    pageUrl: string;
+    title: string | null;
+    textContent: string;
+    truncated: boolean;
+    modelOverride: string | null;
+    lengthRaw: string;
+    languageRaw: string;
+    promptOverride: string | null;
+    noCache: boolean;
+    extractOnly: boolean;
+    mode: DaemonRequestedMode;
+    maxCharacters: number | null;
+    format: "text" | "markdown";
+    overrides: ReturnType<typeof resolveRunOverrides>;
+    slidesSettings: SlideSettings | null;
+    diagnostics: {
+        includeContent: boolean;
+    };
+    hasText: boolean;
+};
+export declare function parseSummarizeRequest({ req, res, cors, env, resolveToolPath, }: {
+    req: http.IncomingMessage;
+    res: http.ServerResponse;
+    cors: Record<string, string>;
+    env: Record<string, string | undefined>;
+    resolveToolPath: (binary: string, env: Record<string, string | undefined>, explicitEnvKey?: string) => string | null;
+}): Promise<ParsedSummarizeRequest | null>;

package/dist/types/daemon/server.d.ts

@@ -1,6 +1,7 @@
-import type { DaemonConfig } from "./config.js";
-import { type SseEvent } from "../shared/sse-events.js";
-type SessionEvent = SseEvent;
+import { type DaemonConfig } from "./config.js";
+import { type SessionEvent } from "./server-session.js";
+export { corsHeaders, isTrustedOrigin } from "./server-http.js";
+export declare function resolveDaemonListenHost(env: Record<string, string | undefined>): string;
 export declare function buildHealthPayload(importMetaUrl?: string): {
     ok: boolean;
     pid: number;
@@ -15,4 +16,3 @@ export declare function runDaemonServer({ env, fetchImpl, config, port, signal,
     onListening?: ((port: number) => void) | null;
     onSessionEvent?: ((event: SessionEvent, sessionId: string) => void) | null;
 }): Promise<void>;
-export {};

package/dist/types/daemon/summarize.d.ts

@@ -1,7 +1,7 @@
 import type { CacheState } from "../cache.js";
+import { type ExtractedLinkContent, type MediaCache } from "../content/index.js";
 import type { RunOverrides } from "../run/run-settings.js";
 import type { SlideExtractionResult, SlideImage, SlideSettings, SlideSourceKind } from "../slides/index.js";
-import { type ExtractedLinkContent, type MediaCache } from "../content/index.js";
 export type VisiblePageInput = {
     url: string;
     title: string | null;

package/dist/types/daemon/windows-container.d.ts

@@ -0,0 +1 @@
+export declare function isWindowsContainerEnvironment(env: Record<string, string | undefined>): boolean;

package/dist/types/llm/cli-exec.d.ts

@@ -0,0 +1,13 @@
+import type { ExecFileFn } from "../markitdown.js";
+export declare function execCliWithInput({ execFileImpl, cmd, args, input, timeoutMs, env, cwd, }: {
+    execFileImpl: ExecFileFn;
+    cmd: string;
+    args: string[];
+    input: string;
+    timeoutMs: number;
+    env: Record<string, string | undefined>;
+    cwd?: string;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;

package/dist/types/llm/cli-provider-output.d.ts

@@ -0,0 +1,25 @@
+import type { CliProvider } from "../config.js";
+import type { LlmTokenUsage } from "./generate-text.js";
+export type JsonCliProvider = Exclude<CliProvider, "codex" | "openclaw" | "opencode">;
+export declare function isJsonCliProvider(provider: CliProvider): provider is JsonCliProvider;
+export declare const parseCodexUsageFromJsonl: (output: string) => {
+    usage: LlmTokenUsage | null;
+    costUsd: number | null;
+};
+export declare function parseCodexOutputFromJsonl(output: string): {
+    text: string | null;
+    sawStructuredEvent: boolean;
+};
+export declare function parseOpenCodeOutputFromJsonl(output: string): {
+    text: string;
+    usage: LlmTokenUsage | null;
+    costUsd: number | null;
+};
+export declare function parseJsonProviderOutput(args: {
+    provider: JsonCliProvider;
+    stdout: string;
+}): {
+    text: string;
+    usage: LlmTokenUsage | null;
+    costUsd: number | null;
+};

package/dist/types/llm/generate-text-document.d.ts

@@ -0,0 +1,35 @@
+import type { LlmProvider } from "./model-id.js";
+import type { Prompt } from "./prompt.js";
+import type { LlmTokenUsage } from "./types.js";
+type ParsedModel = {
+    provider: LlmProvider;
+    model: string;
+    canonical: string;
+};
+type DocumentResult = {
+    text: string;
+    canonicalModelId: string;
+    provider: ParsedModel["provider"];
+    usage: LlmTokenUsage | null;
+};
+export declare function maybeGenerateDocumentText(options: {
+    parsed: ParsedModel;
+    apiKeys: {
+        openaiApiKey: string | null;
+        googleApiKey: string | null;
+        anthropicApiKey: string | null;
+        openrouterApiKey: string | null;
+    };
+    prompt: Prompt;
+    maxOutputTokens?: number;
+    temperature?: number;
+    timeoutMs: number;
+    fetchImpl: typeof fetch;
+    forceOpenRouter?: boolean;
+    openaiBaseUrlOverride?: string | null;
+    anthropicBaseUrlOverride?: string | null;
+    googleBaseUrlOverride?: string | null;
+    forceChatCompletions?: boolean;
+    retryWithModelId: (modelId: string) => Promise<DocumentResult>;
+}): Promise<DocumentResult | null>;
+export {};

package/dist/types/llm/generate-text-shared.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "@mariozechner/pi-ai";
+import type { Prompt } from "./prompt.js";
+import type { LlmTokenUsage } from "./types.js";
+export declare function promptToContext(prompt: Prompt): Context;
+export declare function isRetryableTimeoutError(error: unknown): boolean;
+export declare function computeRetryDelayMs(attempt: number): number;
+export declare function sleep(ms: number): Promise<void>;
+export declare function withTimeoutFallback<T>({ promise, timeoutMs, fallback, }: {
+    promise: Promise<T>;
+    timeoutMs: number;
+    fallback: T;
+}): Promise<T>;
+export declare function streamUsageWithTimeout({ result, timeoutMs, }: {
+    result: Promise<{
+        usage?: unknown;
+    }>;
+    timeoutMs: number;
+}): Promise<LlmTokenUsage | null>;
+export declare function isOpenAiGpt5Model(provider: string, model: string): boolean;
+export declare function resolveEffectiveTemperature({ provider, model, temperature, }: {
+    provider: string;
+    model: string;
+    temperature?: number;
+}): number | undefined;
+export declare function shouldRetryGpt5WithoutTokenCap({ provider, model, maxOutputTokens, error, }: {
+    provider: string;
+    model: string;
+    maxOutputTokens?: number;
+    error: unknown;
+}): boolean;
+export declare function resolveGoogleEmptyResponseFallbackModelId(modelId: string): string | null;
+export declare function isGoogleEmptySummaryError(error: unknown): boolean;

package/dist/types/llm/generate-text-stream.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from "@mariozechner/pi-ai";
+import type { LlmApiKeys } from "./generate-text.js";
+import type { LlmProvider } from "./model-id.js";
+import type { LlmTokenUsage } from "./types.js";
+export type StreamTextWithContextArgs = {
+    modelId: string;
+    apiKeys: LlmApiKeys;
+    context: Context;
+    temperature?: number;
+    maxOutputTokens?: number;
+    timeoutMs: number;
+    fetchImpl: typeof fetch;
+    forceOpenRouter?: boolean;
+    openaiBaseUrlOverride?: string | null;
+    anthropicBaseUrlOverride?: string | null;
+    googleBaseUrlOverride?: string | null;
+    xaiBaseUrlOverride?: string | null;
+    forceChatCompletions?: boolean;
+};
+export type StreamTextResult = {
+    textStream: AsyncIterable<string>;
+    canonicalModelId: string;
+    provider: LlmProvider;
+    usage: Promise<LlmTokenUsage | null>;
+    lastError: () => unknown;
+};
+export declare function streamTextWithContext({ modelId, apiKeys, context, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, }: StreamTextWithContextArgs): Promise<StreamTextResult>;

package/dist/types/llm/generate-text.d.ts

@@ -1,6 +1,7 @@
-import type { Context } from "@mariozechner/pi-ai";
+import type { LlmProvider } from "./model-id.js";
+import type { Prompt } from "./prompt.js";
 import type { LlmTokenUsage } from "./types.js";
-import { type Prompt } from "./prompt.js";
+export { streamTextWithContext } from "./generate-text-stream.js";
 export type LlmApiKeys = {
     xaiApiKey: string | null;
     openaiApiKey: string | null;
@@ -18,7 +19,7 @@ type RetryNotice = {
     delayMs: number;
     error: unknown;
 };
-export declare function generateTextWithModelId({ modelId, apiKeys, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
+export declare function generateTextWithModelId({ modelId, apiKeys, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, zaiBaseUrlOverride, forceChatCompletions, retries, onRetry, }: {
     modelId: string;
     apiKeys: LlmApiKeys;
     prompt: Prompt;
@@ -31,13 +32,14 @@ export declare function generateTextWithModelId({ modelId, apiKeys, prompt, temp
     anthropicBaseUrlOverride?: string | null;
     googleBaseUrlOverride?: string | null;
     xaiBaseUrlOverride?: string | null;
+    zaiBaseUrlOverride?: string | null;
     forceChatCompletions?: boolean;
     retries?: number;
     onRetry?: (notice: RetryNotice) => void;
 }): Promise<{
     text: string;
     canonicalModelId: string;
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+    provider: LlmProvider;
     usage: LlmTokenUsage | null;
 }>;
 export declare function streamTextWithModelId({ modelId, apiKeys, prompt, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, }: {
@@ -57,28 +59,7 @@ export declare function streamTextWithModelId({ modelId, apiKeys, prompt, temper
 }): Promise<{
     textStream: AsyncIterable<string>;
     canonicalModelId: string;
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
-    usage: Promise<LlmTokenUsage | null>;
-    lastError: () => unknown;
-}>;
-export declare function streamTextWithContext({ modelId, apiKeys, context, temperature, maxOutputTokens, timeoutMs, fetchImpl, forceOpenRouter, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, forceChatCompletions, }: {
-    modelId: string;
-    apiKeys: LlmApiKeys;
-    context: Context;
-    temperature?: number;
-    maxOutputTokens?: number;
-    timeoutMs: number;
-    fetchImpl: typeof fetch;
-    forceOpenRouter?: boolean;
-    openaiBaseUrlOverride?: string | null;
-    anthropicBaseUrlOverride?: string | null;
-    googleBaseUrlOverride?: string | null;
-    xaiBaseUrlOverride?: string | null;
-    forceChatCompletions?: boolean;
-}): Promise<{
-    textStream: AsyncIterable<string>;
-    canonicalModelId: string;
-    provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+    provider: LlmProvider;
     usage: Promise<LlmTokenUsage | null>;
     lastError: () => unknown;
 }>;

package/dist/types/llm/github-models.d.ts

@@ -0,0 +1,5 @@
+export declare const GITHUB_MODELS_BASE_URL = "https://models.github.ai/inference";
+export declare const GITHUB_MODELS_API_VERSION = "2026-03-10";
+export declare function resolveGitHubModelsApiKey(env: Record<string, string | undefined>): string | null;
+export declare function resolveGitHubCopilotBackendModelId(model: string): string;
+export declare function buildGitHubModelsHeaders(existing?: Record<string, string>): Record<string, string>;

package/dist/types/llm/html-to-markdown.d.ts

@@ -1,5 +1,6 @@
 import type { ConvertHtmlToMarkdown } from "@steipete/summarize-core/content";
 import type { LlmTokenUsage } from "./generate-text.js";
+import type { LlmProvider } from "./model-id.js";
 export declare function createHtmlToMarkdownConverter({ modelId, forceOpenRouter, xaiApiKey, googleApiKey, openaiApiKey, openaiBaseUrlOverride, anthropicBaseUrlOverride, googleBaseUrlOverride, xaiBaseUrlOverride, anthropicApiKey, openrouterApiKey, fetchImpl, forceChatCompletions, retries, onRetry, onUsage, }: {
     modelId: string;
     forceOpenRouter?: boolean;
@@ -23,7 +24,7 @@ export declare function createHtmlToMarkdownConverter({ modelId, forceOpenRouter
     }) => void;
     onUsage?: (usage: {
         model: string;
-        provider: "xai" | "openai" | "google" | "anthropic" | "zai";
+        provider: LlmProvider;
         usage: LlmTokenUsage | null;
     }) => void;
 }): ConvertHtmlToMarkdown;

package/dist/types/llm/model-id.d.ts

@@ -1,4 +1,4 @@
-export type LlmProvider = "xai" | "openai" | "google" | "anthropic" | "zai";
+export type LlmProvider = "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia" | "github-copilot";
 export type ParsedModelId = {
     provider: LlmProvider;
     /**

package/dist/types/llm/provider-capabilities.d.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_AUTO_CLI_ORDER, DEFAULT_CLI_MODELS, envHasRequiredKey, getGatewayProviderProfile, isVideoUnderstandingCapableModelId, isVideoUnderstandingCapableProvider, parseCliProviderName, requiredEnvForCliProvider, requiredEnvForGatewayProvider, resolveOpenAiCompatibleClientConfigForProvider, resolveRequiredEnvForModelId, supportsDocumentAttachments, supportsStreaming, } from "./provider-profile.js";
+export type { GatewayProvider, RequiredModelEnv } from "./provider-profile.js";

package/dist/types/llm/provider-profile.d.ts

@@ -0,0 +1,31 @@
+import type { CliProvider } from "../config.js";
+import type { OpenAiClientConfig } from "./providers/types.js";
+export type GatewayProvider = "xai" | "openai" | "google" | "anthropic" | "zai" | "nvidia" | "github-copilot";
+export type RequiredModelEnv = "XAI_API_KEY" | "OPENAI_API_KEY" | "NVIDIA_API_KEY" | "GEMINI_API_KEY" | "ANTHROPIC_API_KEY" | "OPENROUTER_API_KEY" | "Z_AI_API_KEY" | "GITHUB_TOKEN" | "CLI_CLAUDE" | "CLI_CODEX" | "CLI_GEMINI" | "CLI_AGENT" | "CLI_OPENCLAW" | "CLI_OPENCODE";
+type GatewayProviderProfile = {
+    requiredEnv: RequiredModelEnv;
+    supportsDocuments: boolean;
+    supportsStreaming: boolean;
+    supportsVideoUnderstanding: boolean;
+};
+export declare const DEFAULT_CLI_MODELS: Record<CliProvider, string | null>;
+export declare const DEFAULT_AUTO_CLI_ORDER: CliProvider[];
+export declare function parseCliProviderName(raw: string): CliProvider | null;
+export declare function requiredEnvForCliProvider(provider: CliProvider): RequiredModelEnv;
+export declare function getGatewayProviderProfile(provider: GatewayProvider): GatewayProviderProfile;
+export declare function requiredEnvForGatewayProvider(provider: GatewayProvider): RequiredModelEnv;
+export declare function supportsDocumentAttachments(provider: GatewayProvider): boolean;
+export declare function supportsStreaming(provider: GatewayProvider): boolean;
+export declare function isVideoUnderstandingCapableProvider(provider: GatewayProvider): boolean;
+export declare function envHasRequiredKey(env: Record<string, string | undefined>, requiredEnv: RequiredModelEnv): boolean;
+export declare function resolveRequiredEnvForModelId(modelId: string): RequiredModelEnv;
+export declare function isVideoUnderstandingCapableModelId(modelId: string): boolean;
+export declare function resolveOpenAiCompatibleClientConfigForProvider({ provider, openaiApiKey, openrouterApiKey, forceOpenRouter, openaiBaseUrlOverride, forceChatCompletions, }: {
+    provider: "openai" | "zai" | "nvidia" | "github-copilot";
+    openaiApiKey: string | null;
+    openrouterApiKey: string | null;
+    forceOpenRouter?: boolean;
+    openaiBaseUrlOverride?: string | null;
+    forceChatCompletions?: boolean;
+}): OpenAiClientConfig;
+export {};