autokap 1.0.7 → 1.0.8

package/dist/legacy/llm-usage.d.ts

@@ -0,0 +1,17 @@
+import type { ChatCompletion } from 'openai/resources/chat/completions';
+import type { StepUsage } from '../types.js';
+export type LlmUsageSnapshot = Pick<StepUsage, 'generationId' | 'modelUsed' | 'promptTokens' | 'completionTokens' | 'totalTokens' | 'cacheReadTokens' | 'cacheWriteTokens' | 'reasoningTokens'>;
+export declare function extractLlmUsageSnapshot(response: ChatCompletion): LlmUsageSnapshot;
+export declare function buildStepUsageFromSnapshot(snapshot: LlmUsageSnapshot, params: {
+    stepNumber: number;
+    stepType: StepUsage['stepType'];
+    modelRequested: string;
+    imagesInPrompt: number;
+}): StepUsage;
+export declare function normalizeLlmUsageSnapshot(snapshot: Partial<LlmUsageSnapshot>): LlmUsageSnapshot;
+export declare function extractStepUsage(response: ChatCompletion, params: {
+    stepNumber: number;
+    stepType: StepUsage['stepType'];
+    modelRequested: string;
+    imagesInPrompt: number;
+}): StepUsage;

package/dist/legacy/llm-usage.js

@@ -0,0 +1,45 @@
+export function extractLlmUsageSnapshot(response) {
+    const usageDetails = response.usage;
+    const promptDetails = usageDetails?.prompt_tokens_details;
+    const completionDetails = usageDetails?.completion_tokens_details;
+    return {
+        generationId: response.id ?? null,
+        modelUsed: response.model ?? null,
+        promptTokens: response.usage?.prompt_tokens ?? null,
+        completionTokens: response.usage?.completion_tokens ?? null,
+        totalTokens: response.usage?.total_tokens ?? null,
+        cacheReadTokens: promptDetails?.cached_tokens
+            ?? usageDetails?.cache_read_input_tokens
+            ?? null,
+        cacheWriteTokens: promptDetails?.cache_creation_input_tokens
+            ?? usageDetails?.cache_write_input_tokens
+            ?? null,
+        reasoningTokens: completionDetails?.reasoning_tokens
+            ?? null,
+    };
+}
+export function buildStepUsageFromSnapshot(snapshot, params) {
+    return {
+        stepNumber: params.stepNumber,
+        stepType: params.stepType,
+        modelRequested: params.modelRequested,
+        imagesInPrompt: params.imagesInPrompt,
+        ...snapshot,
+    };
+}
+export function normalizeLlmUsageSnapshot(snapshot) {
+    return {
+        generationId: snapshot.generationId ?? null,
+        modelUsed: snapshot.modelUsed ?? null,
+        promptTokens: snapshot.promptTokens ?? null,
+        completionTokens: snapshot.completionTokens ?? null,
+        totalTokens: snapshot.totalTokens ?? null,
+        cacheReadTokens: snapshot.cacheReadTokens ?? null,
+        cacheWriteTokens: snapshot.cacheWriteTokens ?? null,
+        reasoningTokens: snapshot.reasoningTokens ?? null,
+    };
+}
+export function extractStepUsage(response, params) {
+    return buildStepUsageFromSnapshot(extractLlmUsageSnapshot(response), params);
+}
+//# sourceMappingURL=llm-usage.js.map

package/dist/legacy/prompt-cache.d.ts

@@ -0,0 +1,10 @@
+export type PromptCacheStrategy = 'implicit_only' | 'explicit_breakpoints' | 'disabled';
+export interface ProviderRoutingPreference {
+    order?: string[];
+    require?: string[];
+    disallow?: string[];
+}
+export declare function resolvePromptCacheStrategy(model: string, options?: {
+    enableGeminiExplicitBreakpoints?: boolean;
+}): PromptCacheStrategy;
+export declare function hasManualMultiProviderOrder(prefs?: ProviderRoutingPreference | null): boolean;

package/dist/legacy/prompt-cache.js

@@ -0,0 +1,24 @@
+export function resolvePromptCacheStrategy(model, options = {}) {
+    const normalized = model.trim().toLowerCase();
+    if (!normalized)
+        return 'disabled';
+    if (normalized.startsWith('anthropic/'))
+        return 'explicit_breakpoints';
+    if (normalized.startsWith('google/') || normalized.includes('gemini')) {
+        return options.enableGeminiExplicitBreakpoints ? 'explicit_breakpoints' : 'implicit_only';
+    }
+    if (normalized.startsWith('x-ai/')
+        || normalized.includes('grok')
+        || normalized.startsWith('openai/')
+        || normalized.startsWith('deepseek/')
+        || normalized.startsWith('moonshot/')
+        || normalized.startsWith('moonshotai/')) {
+        return 'implicit_only';
+    }
+    return 'disabled';
+}
+export function hasManualMultiProviderOrder(prefs) {
+    const providers = prefs?.order?.map((provider) => provider.trim()).filter(Boolean) ?? [];
+    return providers.length > 1;
+}
+//# sourceMappingURL=prompt-cache.js.map

package/dist/legacy/prompts.d.ts

@@ -0,0 +1,175 @@
+import type { ChatCompletionContentPart } from 'openai/resources/chat/completions';
+import type { AgentConfig, AgentRunHint, CaptureCursor, CaptureObjective, CaptureHandoffContext, ExecutedAction, InteractiveElement, LoginCredentials, OverlayScopeSummary, RepairTicket, VariantCaptureManifest, ValidatedSessionProfile, WorkflowScreenshot } from '../types.js';
+interface SystemPromptOptions {
+    reasoningLocale?: string;
+}
+export declare function buildSystemPrompt(opts?: SystemPromptOptions): string;
+interface IterationPromptMetrics {
+    elementsChars: number;
+    sessionSummaryChars: number;
+    selectorMemoryChars: number;
+    agentContextChars: number;
+}
+export interface StableAnchorUserMessageParams {
+    userPrompt: string;
+    credentials?: LoginCredentials;
+    currentLang?: string;
+    currentTheme?: 'light' | 'dark';
+    langInstructions?: string;
+    themeInstructions?: string;
+    viewports?: Array<{
+        width: number;
+        height: number;
+    }>;
+    runHints?: AgentRunHint[];
+    selectorMemory?: Record<string, string[]>;
+    sessionProfile?: ValidatedSessionProfile;
+    handoffContext?: CaptureHandoffContext;
+    variantManifest?: VariantCaptureManifest;
+}
+export interface IterationUserMessageParams {
+    userPrompt: string;
+    serializedAKTree: string;
+    cleanScreenshotUrl?: string;
+    screenshotUrl: string;
+    /** In dual-model mode, the vision model's text observation replaces images. */
+    visionObservation?: string;
+    /** Simplified DOM structure — primary page context in DOM-first mode. */
+    simplifiedDOM?: string;
+    /** When true, the DOM has not changed since the previous iteration (fingerprint match).
+     *  The prompt emits a compact placeholder instead of the full DOM. */
+    domUnchanged?: boolean;
+    accessibilityTree: string;
+    interactiveElements: InteractiveElement[];
+    actionHistory?: ExecutedAction[];
+    screenshotsTaken: WorkflowScreenshot[];
+    iteration: number;
+    maxIterations: number;
+    credentials?: LoginCredentials;
+    currentLang?: string;
+    currentTheme?: 'light' | 'dark';
+    langInstructions?: string;
+    themeInstructions?: string;
+    viewports?: Array<{
+        width: number;
+        height: number;
+    }>;
+    runHints?: AgentRunHint[];
+    selectorMemory?: Record<string, string[]>;
+    sessionProfile?: ValidatedSessionProfile;
+    hasCredentials?: boolean;
+    salienceCompressionEnabled?: boolean;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    currentUrl?: string;
+    stuckLoopWarning?: string;
+    lastVerificationFailure?: string;
+    userGuidance?: string[];
+    scrollInfo?: {
+        scrollY: number;
+        scrollHeight: number;
+        viewportHeight: number;
+    };
+    expansionLevel?: number;
+    /** When true, includes the full task context (prompt, session, memory, instructions).
+     *  When false (subsequent iterations), sends only the compact page observation. */
+    isFirstIteration?: boolean;
+    /** Pre-generated action plan from the planning call. Included in first iteration and on stuck loops. */
+    taskPlan?: string;
+    /** Persistent notes stored by the agent via the `note` tool. Re-injected every iteration. */
+    agentNotes?: string[];
+    /** Current active subgoal name (set by `begin_subgoal` tool). */
+    currentSubgoal?: string;
+    /** Completed subgoals with compressed summaries (HiAgent hierarchical memory). */
+    completedSubgoals?: Array<{
+        name: string;
+        summary: string;
+    }>;
+    /** Compact deterministic log of all actions taken so far (survives conversation trimming). */
+    trajectoryLog?: string;
+    /** Live browser state handed off from the previous capture in the same run. */
+    handoffContext?: CaptureHandoffContext;
+    /** Explicit multi-page manifest for the current variant/page. */
+    variantManifest?: VariantCaptureManifest;
+    currentObjective?: CaptureObjective;
+    captureCursor?: CaptureCursor;
+    activeRepairTicket?: RepairTicket | null;
+    remainingCaptureQueue?: string[];
+    cacheLayoutV2?: boolean;
+    /** Reference from variant 1 — what state was achieved for this page in the first variant. */
+    variantReference?: {
+        finalUrl: string;
+        assessment: string;
+        pageTitle: string;
+        /** Full action sequence from variant 1 — helps the LLM retrace the path. */
+        actions?: ExecutedAction[];
+    };
+    /** Compact summary of recent failed actions — prevents the agent from repeating dead-end strategies. */
+    failedAttemptsSummary?: string;
+    /** When true, the browser is already on the target URL — the agent should check and capture, not navigate. */
+    alreadyOnTarget?: boolean;
+    promptFingerprint?: string;
+    overlayScope?: OverlayScopeSummary | null;
+}
+export declare function buildStableAnchorUserMessage(params: StableAnchorUserMessageParams): {
+    content: ChatCompletionContentPart[];
+    metrics: IterationPromptMetrics;
+};
+export declare function buildIterationUserMessage(params: IterationUserMessageParams): {
+    content: ChatCompletionContentPart[];
+    metrics: IterationPromptMetrics;
+};
+export declare function buildVerificationMessage(params: {
+    userPrompt: string;
+    screenshotUrl: string;
+    previousAssessment: string;
+    runMode?: AgentConfig['runMode'];
+    currentLang?: string;
+    currentTheme?: 'light' | 'dark';
+    pageContext?: {
+        currentUrl?: string;
+        pageTitle?: string;
+    };
+    runHints?: AgentRunHint[];
+    variantManifest?: VariantCaptureManifest;
+    verificationDiagnostics?: {
+        lang?: string;
+        theme?: string;
+    };
+    identityHints?: string[];
+}): ChatCompletionContentPart[];
+export declare function buildVisionObserverPrompt(params: {
+    screenshotUrl: string;
+    currentUrl: string;
+    interactiveElements: InteractiveElement[];
+    userGoal: string;
+    question?: string;
+    currentLang?: string;
+    currentTheme?: 'light' | 'dark';
+    currentPageId?: string;
+    pageIdentitySummary?: string;
+    currentObjective?: string;
+}): ChatCompletionContentPart[];
+export declare function buildElementSystemPrompt(description: string): string;
+export declare function buildElementIterationMessage(params: {
+    elementName: string;
+    elementDescription: string;
+    serializedAKTree: string;
+    currentUrl: string;
+    iteration: number;
+    maxIterations: number;
+    actionHistory?: string[];
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    scrollInfo?: {
+        scrollY: number;
+        scrollHeight: number;
+        viewportHeight: number;
+    };
+    screenshotUrl?: string;
+}): ChatCompletionContentPart[];
+export {};