@remnic/core 1.0.0

package/dist/evals.d.ts

@@ -0,0 +1,282 @@
+type EvalRunStatus = "running" | "completed" | "failed" | "partial";
+interface EvalBenchmarkCase {
+    id: string;
+    prompt: string;
+    expectedSignals?: string[];
+    notes?: string;
+}
+type EvalBenchmarkType = "standard" | "memory-red-team";
+interface EvalBenchmarkManifest {
+    schemaVersion: 1;
+    benchmarkId: string;
+    benchmarkType?: EvalBenchmarkType;
+    title: string;
+    description?: string;
+    tags?: string[];
+    sourceLinks?: string[];
+    attackClass?: string;
+    targetSurface?: string;
+    cases: EvalBenchmarkCase[];
+}
+interface EvalRunMetrics {
+    recallPrecisionAtK?: number;
+    actionOutcomeScore?: number;
+    objectiveStateCoverage?: number;
+    causalPathRecall?: number;
+    trustViolationRate?: number;
+    creationRecoveryScore?: number;
+}
+interface EvalRunSummary {
+    schemaVersion: 1;
+    runId: string;
+    benchmarkId: string;
+    status: EvalRunStatus;
+    startedAt: string;
+    completedAt?: string;
+    totalCases: number;
+    passedCases: number;
+    failedCases: number;
+    metrics?: EvalRunMetrics;
+    notes?: string;
+    gitRef?: string;
+}
+interface EvalShadowRecallRecord {
+    schemaVersion: 1;
+    traceId: string;
+    recordedAt: string;
+    sessionKey: string;
+    promptHash: string;
+    promptLength: number;
+    retrievalQueryHash: string;
+    retrievalQueryLength: number;
+    recallMode: "no_recall" | "minimal" | "full" | "graph_mode";
+    recallResultLimit: number;
+    source: "none" | "hot_qmd" | "hot_embedding" | "cold_fallback" | "recent_scan";
+    recalledMemoryCount: number;
+    injected: boolean;
+    contextChars: number;
+    memoryIds: string[];
+    policyVersion?: string;
+    identityInjectionMode?: "recovery_only" | "minimal" | "full" | "none";
+    identityInjectedChars?: number;
+    identityInjectionTruncated?: boolean;
+    durationMs: number;
+    timings?: Record<string, string>;
+}
+interface EvalHarnessStatus {
+    enabled: boolean;
+    shadowModeEnabled: boolean;
+    rootDir: string;
+    benchmarkDir: string;
+    runsDir: string;
+    benchmarks: {
+        total: number;
+        valid: number;
+        invalid: number;
+        redTeam: number;
+        totalCases: number;
+        attackClasses: string[];
+        tags: string[];
+        targetSurfaces: string[];
+        sourceLinks: string[];
+    };
+    runs: {
+        total: number;
+        invalid: number;
+        completed: number;
+        failed: number;
+        partial: number;
+        running: number;
+        latestRunId?: string;
+        latestBenchmarkId?: string;
+        latestCompletedAt?: string;
+    };
+    shadows: {
+        total: number;
+        invalid: number;
+        latestTraceId?: string;
+        latestRecordedAt?: string;
+        latestSessionKey?: string;
+    };
+    baselines: {
+        enabled: boolean;
+        total: number;
+        invalid: number;
+        latestSnapshotId?: string;
+        latestCreatedAt?: string;
+        latestBenchmarkCount?: number;
+    };
+    latestRun?: EvalRunSummary;
+    latestShadow?: EvalShadowRecallRecord;
+    latestBaseline?: EvalBaselineSnapshot;
+    invalidBenchmarks: Array<{
+        path: string;
+        error: string;
+    }>;
+    invalidRuns: Array<{
+        path: string;
+        error: string;
+    }>;
+    invalidShadows: Array<{
+        path: string;
+        error: string;
+    }>;
+    invalidBaselines: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+interface EvalBenchmarkDelta {
+    benchmarkId: string;
+    baseRunId: string;
+    candidateRunId: string;
+    basePassRate: number;
+    candidatePassRate: number;
+    passRateDelta: number;
+    metricDeltas: Partial<Record<keyof EvalRunMetrics, number>>;
+    regressions: string[];
+    improvements: string[];
+}
+interface EvalCiGateReport {
+    passed: boolean;
+    baseRootDir: string;
+    candidateRootDir: string;
+    comparedBenchmarks: number;
+    missingCandidateBenchmarks: string[];
+    invalidArtifacts: {
+        base: {
+            benchmarks: number;
+            runs: number;
+            shadows: number;
+        };
+        candidate: {
+            benchmarks: number;
+            runs: number;
+            shadows: number;
+        };
+    };
+    regressions: string[];
+    improvements: string[];
+    deltas: EvalBenchmarkDelta[];
+}
+interface EvalBaselineDeltaReport {
+    passed: boolean;
+    baselineSnapshotId: string;
+    baselineCreatedAt: string;
+    baselineSourceRootDir: string;
+    candidateRootDir: string;
+    comparedBenchmarks: number;
+    missingCandidateBenchmarks: string[];
+    invalidArtifacts: {
+        candidate: {
+            benchmarks: number;
+            runs: number;
+            shadows: number;
+            baselines: number;
+        };
+    };
+    regressions: string[];
+    improvements: string[];
+    deltas: EvalBenchmarkDelta[];
+    markdownReport: string;
+}
+interface EvalStoredBaselineCiGateReport extends EvalBaselineDeltaReport {
+    baseRootDir: string;
+    baselineResolvedFrom: "base" | "candidate";
+}
+interface EvalBaselineSnapshotBenchmark {
+    benchmarkId: string;
+    runId: string;
+    completedAt?: string;
+    gitRef?: string;
+    passRate: number;
+    metrics?: EvalRunMetrics;
+}
+interface EvalBaselineSnapshot {
+    schemaVersion: 1;
+    snapshotId: string;
+    createdAt: string;
+    sourceRootDir: string;
+    benchmarkCount: number;
+    benchmarks: EvalBaselineSnapshotBenchmark[];
+    notes?: string;
+    gitRef?: string;
+}
+interface EvalBenchmarkPackSummary {
+    sourcePath: string;
+    manifestPath: string;
+    benchmarkId: string;
+    benchmarkType: EvalBenchmarkType;
+    title: string;
+    attackClass?: string;
+    targetSurface?: string;
+    totalCases: number;
+    tags: string[];
+    sourceLinks: string[];
+}
+declare function resolveEvalStoreDir(memoryDir: string, overrideDir?: string): string;
+declare function validateEvalBenchmarkManifest(raw: unknown, options?: {
+    memoryRedTeamBenchEnabled?: boolean;
+}): EvalBenchmarkManifest;
+declare function validateEvalRunSummary(raw: unknown): EvalRunSummary;
+declare function validateEvalBaselineSnapshot(raw: unknown): EvalBaselineSnapshot;
+declare function validateEvalShadowRecallRecord(raw: unknown): EvalShadowRecallRecord;
+declare function validateEvalBenchmarkPack(sourcePath: string, options?: {
+    memoryRedTeamBenchEnabled?: boolean;
+}): Promise<EvalBenchmarkPackSummary>;
+declare function importEvalBenchmarkPack(options: {
+    sourcePath: string;
+    memoryDir: string;
+    evalStoreDir?: string;
+    force?: boolean;
+    memoryRedTeamBenchEnabled?: boolean;
+}): Promise<EvalBenchmarkPackSummary & {
+    targetDir: string;
+    overwritten: boolean;
+}>;
+declare function recordEvalShadowRecall(options: {
+    memoryDir: string;
+    evalStoreDir?: string;
+    record: EvalShadowRecallRecord;
+}): Promise<string>;
+declare function getEvalHarnessStatus(options: {
+    memoryDir: string;
+    evalStoreDir?: string;
+    enabled: boolean;
+    shadowModeEnabled: boolean;
+    baselineSnapshotsEnabled?: boolean;
+    memoryRedTeamBenchEnabled?: boolean;
+}): Promise<EvalHarnessStatus>;
+declare function createEvalBaselineSnapshot(options: {
+    memoryDir: string;
+    evalStoreDir?: string;
+    baselineSnapshotsEnabled: boolean;
+    snapshotId: string;
+    createdAt?: string;
+    notes?: string;
+    gitRef?: string;
+}): Promise<{
+    targetPath: string;
+    snapshot: EvalBaselineSnapshot;
+}>;
+declare function runEvalBaselineDeltaReport(options: {
+    memoryDir: string;
+    evalStoreDir?: string;
+    benchmarkDeltaReporterEnabled: boolean;
+    snapshotId: string;
+}): Promise<EvalBaselineDeltaReport>;
+declare function runEvalStoredBaselineCiGate(options: {
+    baseMemoryDir?: string;
+    baseEvalStoreDir: string;
+    candidateMemoryDir?: string;
+    candidateEvalStoreDir: string;
+    snapshotId: string;
+}): Promise<EvalStoredBaselineCiGateReport>;
+declare function runEvalBenchmarkCiGate(options: {
+    baseMemoryDir?: string;
+    candidateMemoryDir?: string;
+    baseEvalStoreDir?: string;
+    candidateEvalStoreDir?: string;
+}): Promise<EvalCiGateReport>;
+
+export { type EvalBaselineDeltaReport, type EvalBaselineSnapshot, type EvalBaselineSnapshotBenchmark, type EvalBenchmarkCase, type EvalBenchmarkDelta, type EvalBenchmarkManifest, type EvalBenchmarkPackSummary, type EvalBenchmarkType, type EvalCiGateReport, type EvalHarnessStatus, type EvalRunMetrics, type EvalRunStatus, type EvalRunSummary, type EvalShadowRecallRecord, type EvalStoredBaselineCiGateReport, createEvalBaselineSnapshot, getEvalHarnessStatus, importEvalBenchmarkPack, recordEvalShadowRecall, resolveEvalStoreDir, runEvalBaselineDeltaReport, runEvalBenchmarkCiGate, runEvalStoredBaselineCiGate, validateEvalBaselineSnapshot, validateEvalBenchmarkManifest, validateEvalBenchmarkPack, validateEvalRunSummary, validateEvalShadowRecallRecord };

package/dist/evals.js

@@ -0,0 +1,32 @@
+import {
+  createEvalBaselineSnapshot,
+  getEvalHarnessStatus,
+  importEvalBenchmarkPack,
+  recordEvalShadowRecall,
+  resolveEvalStoreDir,
+  runEvalBaselineDeltaReport,
+  runEvalBenchmarkCiGate,
+  runEvalStoredBaselineCiGate,
+  validateEvalBaselineSnapshot,
+  validateEvalBenchmarkManifest,
+  validateEvalBenchmarkPack,
+  validateEvalRunSummary,
+  validateEvalShadowRecallRecord
+} from "./chunk-K6WK37A6.js";
+import "./chunk-LPSF4OQH.js";
+export {
+  createEvalBaselineSnapshot,
+  getEvalHarnessStatus,
+  importEvalBenchmarkPack,
+  recordEvalShadowRecall,
+  resolveEvalStoreDir,
+  runEvalBaselineDeltaReport,
+  runEvalBenchmarkCiGate,
+  runEvalStoredBaselineCiGate,
+  validateEvalBaselineSnapshot,
+  validateEvalBenchmarkManifest,
+  validateEvalBenchmarkPack,
+  validateEvalRunSummary,
+  validateEvalShadowRecallRecord
+};
+//# sourceMappingURL=evals.js.map

package/dist/evals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/explicit-capture.d.ts

@@ -0,0 +1,60 @@
+import { O as Orchestrator } from './orchestrator-zTa-Qo-1.js';
+import { MemoryCategory, PluginConfig } from './types.js';
+import './buffer.js';
+import './storage.js';
+import './memory-projection-store-NxMkbocT.js';
+import 'better-sqlite3';
+import './port-C1GZFv8h.js';
+import './transcript.js';
+import './session-integrity.js';
+import './summarizer.js';
+import './model-registry.js';
+import './local-llm.js';
+import './relevance.js';
+import './negative.js';
+import './recall-state.js';
+import './session-observer-state.js';
+import './embedding-fallback.js';
+import './semantic-consolidation.js';
+import 'zod';
+import './policy-runtime.js';
+import './profiling.js';
+
+type ExplicitCaptureInput = {
+    content: string;
+    category?: string;
+    confidence?: number;
+    namespace?: string;
+    tags?: string[];
+    entityRef?: string;
+    ttl?: string;
+    sourceReason?: string;
+};
+type ValidExplicitCapture = {
+    content: string;
+    category: MemoryCategory;
+    confidence: number;
+    namespace?: string;
+    tags: string[];
+    entityRef?: string;
+    expiresAt?: string;
+    sourceReason?: string;
+};
+type ExplicitCaptureSource = "memory_store" | "memory_capture" | "suggestion_submit" | "inline";
+type ExplicitCaptureValidationMode = "legacy_tool" | "strict_explicit";
+declare function parseInlineExplicitCaptureNotes(text: string): ExplicitCaptureInput[];
+declare function hasInlineExplicitCaptureMarkup(text: string): boolean;
+declare function stripInlineExplicitCaptureNotes(text: string): string;
+declare function validateExplicitCaptureInput(input: ExplicitCaptureInput, mode?: ExplicitCaptureValidationMode): ValidExplicitCapture;
+declare function persistExplicitCapture(orchestrator: Orchestrator, candidate: ValidExplicitCapture, source: ExplicitCaptureSource): Promise<{
+    id: string;
+    duplicateOf?: string;
+}>;
+declare function queueExplicitCaptureForReview(orchestrator: Orchestrator, input: ExplicitCaptureInput, source: ExplicitCaptureSource, error: unknown): Promise<{
+    id: string;
+    duplicateOf?: string;
+}>;
+declare function shouldSkipImplicitExtraction(cfg: Pick<PluginConfig, "captureMode">): boolean;
+declare function shouldProcessInlineExplicitCapture(cfg: Pick<PluginConfig, "captureMode">): boolean;
+
+export { type ExplicitCaptureInput, type ExplicitCaptureSource, type ValidExplicitCapture, hasInlineExplicitCaptureMarkup, parseInlineExplicitCaptureNotes, persistExplicitCapture, queueExplicitCaptureForReview, shouldProcessInlineExplicitCapture, shouldSkipImplicitExtraction, stripInlineExplicitCaptureNotes, validateExplicitCaptureInput };

package/dist/explicit-capture.js

@@ -0,0 +1,23 @@
+import {
+  hasInlineExplicitCaptureMarkup,
+  parseInlineExplicitCaptureNotes,
+  persistExplicitCapture,
+  queueExplicitCaptureForReview,
+  shouldProcessInlineExplicitCapture,
+  shouldSkipImplicitExtraction,
+  stripInlineExplicitCaptureNotes,
+  validateExplicitCaptureInput
+} from "./chunk-YNCQ7E4M.js";
+import "./chunk-HLXVTBF3.js";
+import "./chunk-M62O4P4T.js";
+export {
+  hasInlineExplicitCaptureMarkup,
+  parseInlineExplicitCaptureNotes,
+  persistExplicitCapture,
+  queueExplicitCaptureForReview,
+  shouldProcessInlineExplicitCapture,
+  shouldSkipImplicitExtraction,
+  stripInlineExplicitCaptureNotes,
+  validateExplicitCaptureInput
+};
+//# sourceMappingURL=explicit-capture.js.map

package/dist/explicit-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/extraction.d.ts

@@ -0,0 +1,141 @@
+import { LocalLlmClient } from './local-llm.js';
+import { ContradictionVerificationResult, SuggestedLinks, MemorySummaryResult } from './schemas.js';
+import { PluginConfig, GatewayConfig, BufferTurn, ExtractionResult, MemoryFile, ConsolidationResult, DaySummaryResult } from './types.js';
+import { ModelRegistry } from './model-registry.js';
+import { ProfilingCollector } from './profiling.js';
+import 'zod';
+
+declare class ExtractionEngine {
+    private readonly config;
+    private client;
+    private localLlm;
+    private fallbackLlm;
+    private modelRegistry;
+    private profiler;
+    constructor(config: PluginConfig, profilerArg?: ProfilingCollector, localLlm?: LocalLlmClient, gatewayConfig?: GatewayConfig, modelRegistry?: ModelRegistry);
+    /**
+     * Whether LLM calls should be routed through the gateway model chain
+     * instead of the plugin's own local/OpenAI clients.
+     */
+    private get useGatewayModelSource();
+    /**
+     * Whether the local LLM path should be attempted.
+     * Disabled when gateway model source is active (gateway chain replaces local).
+     */
+    private get shouldUseLocalLlm();
+    /**
+     * Whether the direct OpenAI client should be used.
+     * Disabled when gateway model source is active.
+     */
+    private get shouldUseDirectClient();
+    /**
+     * Build FallbackLlmOptions with the configured gateway agent ID injected.
+     */
+    private withGatewayAgent;
+    private emit;
+    private directClientUsesOpenAiTokenSemantics;
+    private sanitizeExtractionResult;
+    private hasExtractionOutputs;
+    private normalizeExtractionResultPayload;
+    private parseJsonObject;
+    private normalizeContradictionVerificationResult;
+    private normalizeSuggestedLinksResult;
+    private normalizeMemorySummaryResult;
+    private normalizeDaySummaryResult;
+    private sanitizeConsolidationResult;
+    private applyProactiveQuestionPass;
+    private parseProactiveQuestionsFromText;
+    private parseProactiveExtractionResultFromText;
+    private generateProactiveQuestions;
+    private answerProactiveQuestions;
+    private mergeProactiveExtractionPass;
+    private parseWithGatewayFallback;
+    extract(turns: BufferTurn[], existingEntities?: string[]): Promise<ExtractionResult>;
+    /**
+     * Extract memories using local LLM with JSON mode.
+     * Uses a minimal prompt to fit within local model context limits (typically 4k-8k).
+     */
+    private extractWithLocalLlm;
+    /**
+     * Extract memories using direct OpenAI-compatible client (Chat Completions API).
+     * Works with Scryr, OpenRouter, and other OpenAI-compatible endpoints.
+     */
+    private extractWithDirectClient;
+    /**
+     * Extract partial facts from truncated JSON responses.
+     * Local LLMs sometimes hit token limits mid-JSON. This tries to salvage valid facts.
+     */
+    private extractPartialFacts;
+    /**
+     * Build extraction instructions shared between local and cloud LLM.
+     */
+    private buildExtractionInstructions;
+    consolidate(newMemories: MemoryFile[], existingMemories: MemoryFile[], currentProfile: string): Promise<ConsolidationResult>;
+    /**
+     * Consolidate memories using local LLM.
+     */
+    private consolidateWithLocalLlm;
+    /**
+     * Consolidate a bloated profile.md into a compact version.
+     * The LLM merges duplicates, removes stale info, and preserves section structure.
+     * Returns the consolidated markdown or null on failure.
+     */
+    consolidateProfile(fullProfileContent: string, targetLines?: number): Promise<{
+        consolidatedProfile: string;
+        removedCount: number;
+        summary: string;
+    } | null>;
+    /**
+     * Consolidate profile using local LLM.
+     */
+    private consolidateProfileWithLocalLlm;
+    /**
+     * Consolidate IDENTITY.md reflections into a concise "Learned Patterns" section.
+     * Returns the new content for the IDENTITY.md file (everything below the static header).
+     */
+    consolidateIdentity(fullIdentityContent: string, staticHeaderEndMarker: string): Promise<{
+        learnedPatterns: string[];
+        summary: string;
+    } | null>;
+    /**
+     * Consolidate identity using local LLM.
+     */
+    private consolidateIdentityWithLocalLlm;
+    /**
+     * Verify if two memories contradict each other using LLM.
+     * Called when QMD finds semantically similar memories (Phase 2B).
+     */
+    verifyContradiction(newMemory: {
+        content: string;
+        category: string;
+    }, existingMemory: {
+        id: string;
+        content: string;
+        category: string;
+        created: string;
+    }): Promise<ContradictionVerificationResult | null>;
+    /**
+     * Suggest links between a new memory and existing memories (Phase 3A).
+     * Called during extraction to build the knowledge graph.
+     */
+    suggestLinks(newMemory: {
+        content: string;
+        category: string;
+    }, candidateMemories: Array<{
+        id: string;
+        content: string;
+        category: string;
+    }>): Promise<SuggestedLinks | null>;
+    generateDaySummary(memories: string | MemoryFile[]): Promise<DaySummaryResult | null>;
+    /**
+     * Summarize a batch of old memories into a compact summary (Phase 4A).
+     */
+    summarizeMemories(memories: Array<{
+        id: string;
+        content: string;
+        category: string;
+        created: string;
+    }>): Promise<MemorySummaryResult | null>;
+}
+
+export { ExtractionEngine };

package/dist/extraction.js

@@ -0,0 +1,22 @@
+import {
+  ExtractionEngine
+} from "./chunk-QFQVZOGA.js";
+import "./chunk-MWGVGUIS.js";
+import "./chunk-763GUIOU.js";
+import "./chunk-ONRU4L2N.js";
+import "./chunk-MDDAA2AO.js";
+import "./chunk-2PO5ZRKV.js";
+import "./chunk-VEWZZM3H.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-KT4NEUNF.js";
+import "./chunk-LU3GQNDQ.js";
+import "./chunk-Y27UJK6V.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-EEQLFRUM.js";
+import "./chunk-M62O4P4T.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  ExtractionEngine
+};
+//# sourceMappingURL=extraction.js.map

package/dist/extraction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/fallback-llm.d.ts

@@ -0,0 +1,95 @@
+import { GatewayConfig } from './types.js';
+
+interface FallbackLlmOptions {
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    /** Override which agent persona's model chain to use (by ID from agents.list[]). */
+    agentId?: string;
+}
+interface FallbackLlmResponse {
+    content: string;
+    modelUsed: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+}
+/**
+ * Generic fallback LLM client that uses the gateway's default AI configuration
+ * and walks through the full fallback chain (primary + fallbacks).
+ * Supports OpenAI and Anthropic API formats.
+ */
+declare class FallbackLlmClient {
+    private gatewayConfig;
+    constructor(gatewayConfig?: GatewayConfig);
+    /**
+     * Check if fallback is available (gateway config has at least one model).
+     */
+    isAvailable(agentId?: string): boolean;
+    /**
+     * Make a chat completion request using the gateway's default AI chain.
+     * Tries primary first, then each fallback in order.
+     * When agentId is provided, uses that agent persona's model chain instead of defaults.
+     */
+    chatCompletion(messages: Array<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>, options?: FallbackLlmOptions): Promise<FallbackLlmResponse | null>;
+    /**
+     * Make a request with structured output (Zod schema).
+     * Returns parsed JSON or null on failure.
+     */
+    parseWithSchema<T>(messages: Array<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>, schema: {
+        parse: (data: unknown) => T;
+    }, options?: FallbackLlmOptions): Promise<T | null>;
+    /**
+     * Like parseWithSchema but also returns the model that was used,
+     * so callers can emit accurate trace events.
+     */
+    parseWithSchemaDetailed<T>(messages: Array<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>, schema: {
+        parse: (data: unknown) => T;
+    }, options?: FallbackLlmOptions): Promise<{
+        result: T;
+        modelUsed: string;
+    } | null>;
+    /**
+     * Get the full model chain from gateway config.
+     * Returns array of models in order: [primary, fallback1, fallback2, ...]
+     *
+     * When agentId is provided, looks up the matching entry in agents.list[]
+     * and uses that persona's model chain. Falls back to agents.defaults.model
+     * if agentId is not found or not provided.
+     */
+    private getModelChain;
+    /**
+     * Parse a "provider/model" string and look up its config.
+     */
+    private parseModelString;
+    /**
+     * Resolve the API key for a provider, handling OpenClaw secret ref formats.
+     * Results are cached per provider so exec calls only happen once.
+     */
+    private resolveApiKey;
+    /**
+     * Try to call a single model.
+     */
+    private tryModel;
+    /**
+     * Call OpenAI-compatible API.
+     */
+    private callOpenAI;
+    /**
+     * Call Anthropic Messages API.
+     */
+    private callAnthropic;
+}
+
+export { FallbackLlmClient, type FallbackLlmOptions, type FallbackLlmResponse };

package/dist/fallback-llm.js

@@ -0,0 +1,12 @@
+import {
+  FallbackLlmClient
+} from "./chunk-KT4NEUNF.js";
+import "./chunk-LU3GQNDQ.js";
+import "./chunk-Y27UJK6V.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  FallbackLlmClient
+};
+//# sourceMappingURL=fallback-llm.js.map

package/dist/fallback-llm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}