@aiscene/core 9.0.6 → 9.0.8

package/dist/types/agent/ui-observer.d.ts

@@ -0,0 +1,103 @@
+import { UIObservationRecordWriter } from '@aiscene/shared/agent-tools/observation-record';
+import type { BaseUIObserverOptions, UIObservationRecord } from '@aiscene/shared/agent-tools/types';
+import type { TUserPrompt } from '../common';
+import type { DeviceFrameSource } from '../device';
+import type { AgentAssertResult, InsightAPI, ObservationAssertOptions, ObservationQueryOptions, ServiceExtractParam, UIContext } from '../types';
+/** Options for a UI observation window. */
+export type UIObserverOption = BaseUIObserverOptions;
+interface UIObserverDeps {
+    openFrameSource: () => Promise<DeviceFrameSource | undefined>;
+    captureRawScreenshot: () => Promise<string>;
+    capturePreparedRepresentative: () => Promise<UIContext>;
+    createInsight: (record: UIObservationRecord) => InsightAPI;
+    onStopped?: () => void;
+    onDisposed?: () => void;
+    screenshotShrinkFactor?: number;
+    /** Test/internal persistence override; not part of the Agent SDK options. */
+    observationRecordWriter?: UIObservationRecordWriter;
+}
+/** A fixed screen-recording window that supports read-only AI insights. */
+export interface UIObservation extends InsightAPI<ObservationQueryOptions, ObservationAssertOptions> {
+    /** Number of captured frames in the fixed observation window. */
+    readonly frameCount: number;
+    /** Timestamp when screen sampling started. */
+    readonly startedAt: number;
+    /** Timestamp when screen sampling ended. */
+    readonly endedAt: number;
+    /** Release image files owned by this observation. Failed cleanup is retryable. */
+    dispose(): Promise<void>;
+}
+/** Recording lifecycle returned by {@link Agent.startObserving}. */
+export interface UIObserver {
+    /** Number of frames currently buffered while recording. */
+    readonly bufferedFrameCount: number;
+    /** Stop recording and return its fixed observation window. */
+    stop(): Promise<UIObservation>;
+    /** Stop recording if needed and release its image files. */
+    dispose(): Promise<void>;
+}
+/** @internal Concrete fixed-window implementation. */
+export declare class UIObservationImpl implements UIObservation {
+    private readonly insight;
+    private readonly disposeRecord?;
+    private readonly onDisposed?;
+    private disposed;
+    private readonly record;
+    constructor(record: UIObservationRecord, insight: InsightAPI, disposeRecord?: (() => void) | undefined, onDisposed?: (() => void) | undefined);
+    get frameCount(): number;
+    get startedAt(): number;
+    get endedAt(): number;
+    private ensureUsable;
+    private ensureFixedWindowOptions;
+    aiQuery<ReturnType = any>(demand: ServiceExtractParam, options?: ObservationQueryOptions): Promise<ReturnType>;
+    aiBoolean(prompt: TUserPrompt, options?: ObservationQueryOptions): Promise<boolean>;
+    aiNumber(prompt: TUserPrompt, options?: ObservationQueryOptions): Promise<number>;
+    aiString(prompt: TUserPrompt, options?: ObservationQueryOptions): Promise<string>;
+    aiAsk(prompt: TUserPrompt, options?: ObservationQueryOptions): Promise<string>;
+    aiAssert(assertion: TUserPrompt, message?: string, options?: ObservationAssertOptions): Promise<AgentAssertResult | undefined>;
+    /** @internal Used only by the CLI observation artifact adapter. */
+    exportRecord(): Promise<UIObservationRecord>;
+    dispose(): Promise<void>;
+}
+/**
+ * Observe an explicit screen window and produce a fixed UIObservation.
+ */
+export declare class UIObserverImpl implements UIObserver {
+    private readonly deps;
+    private frames;
+    private source;
+    private usingFallback;
+    private stopped;
+    private disposed;
+    private loopPromise;
+    private stopPromise;
+    private representative;
+    private representativeFrame;
+    private watchdogTimer;
+    private persistPromise;
+    private persistedByRef;
+    private observation;
+    private startedAt;
+    private readonly intervalMs;
+    private readonly maxFrames;
+    private readonly watchdogMs;
+    private readonly screenshotShrinkFactor;
+    private readonly writer;
+    constructor(deps: UIObserverDeps, opt?: UIObserverOption);
+    get bufferedFrameCount(): number;
+    start(): Promise<void>;
+    stop(): Promise<UIObservationImpl>;
+    private finalizeStop;
+    private finalizeRecord;
+    /** Release writer-owned image files after the observation is no longer needed. */
+    dispose(): Promise<void>;
+    private persistUnstoredFrames;
+    private captureOnce;
+    private runLoop;
+    private pushFrame;
+    private thinBuffer;
+    private dedupeRefs;
+}
+/** Rebuild model-facing temporal context from resolved image file paths. */
+export declare function uiContextFromObservationRecord(record: UIObservationRecord): UIContext;
+export {};

package/dist/types/agent/utils.d.ts

@@ -1,6 +1,6 @@
 import type { TMultimodalPrompt, TUserPrompt } from '../common';
 import type { AbstractInterface } from '../device';
-import type { ElementCacheFeature, LocateResultElement, PlanningLocateParam, Rect, UIContext } from '../types';
+import type { ElementCacheFeature, LocateResultElement, PlanningLocateParam, Rect, Size, UIContext } from '../types';
 import type { TModelFamily } from '@aiscene/shared/env';
 import type { TaskCache } from './task-cache';
 export declare function commonContextParser(interfaceInstance: AbstractInterface, _opt: {
@@ -8,6 +8,9 @@ export declare function commonContextParser(interfaceInstance: AbstractInterface
     screenshotShrinkFactor?: number;
     modelFamily?: TModelFamily;
 }): Promise<UIContext>;
+export declare function createScreenshotBoundUIContext(screenshotBase64: string, opt: {
+    screenshotSize?: Size;
+}): Promise<UIContext>;
 export declare function getReportFileName(tag?: string): string;
 export declare function printReportMsg(filepath: string): void;
 export declare function ifPlanLocateParamIsBbox(planLocateParam: PlanningLocateParam): boolean;
@@ -21,5 +24,13 @@ export declare const parsePrompt: (prompt: TUserPrompt) => {
     textPrompt: string;
     multimodalPrompt?: TMultimodalPrompt;
 };
+type NormalizeFilePathsOptions = {
+    fileExists?: (path: string) => boolean;
+    isInBrowser?: boolean;
+    resolvePath?: (path: string) => string;
+    cwd?: string;
+};
+export declare function normalizeFilePaths(files: string[], options?: NormalizeFilePathsOptions): string[];
 export declare const transformLogicalElementToScreenshot: (element: LocateResultElement, shrunkShotToLogicalRatio: number) => LocateResultElement;
 export declare const transformLogicalRectToScreenshotRect: (rect: Rect, shrunkShotToLogicalRatio: number) => Rect;
+export {};

package/dist/types/ai-model/connectivity/fixture.d.ts

@@ -0,0 +1,5 @@
+export declare const CONNECTIVITY_FIXTURE_IMAGE = "data:image/png;base64,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";
+export declare const CONNECTIVITY_FIXTURE_SHOT_SIZE: {
+    width: number;
+    height: number;
+};

package/dist/types/ai-model/connectivity/index.d.ts

@@ -0,0 +1 @@
+export { runConnectivityTest, type ConnectivityTestConfig, type ConnectivityTestResult, } from './run-connectivity-test';

package/dist/types/ai-model/connectivity/run-connectivity-test.d.ts

@@ -0,0 +1,11 @@
+import type { IModelConfig } from '@aiscene/shared/env';
+export interface ConnectivityTestResult {
+    passed: boolean;
+    message?: string;
+}
+export interface ConnectivityTestConfig {
+    defaultModelConfig: IModelConfig;
+    planningModelConfig: IModelConfig;
+    insightModelConfig: IModelConfig;
+}
+export declare function runConnectivityTest(config: ConnectivityTestConfig): Promise<ConnectivityTestResult>;

package/dist/types/ai-model/index.d.ts

@@ -6,6 +6,8 @@ export { generateYamlTest, generateYamlTestStream, } from './prompt/yaml-generat
 export type { YamlGenerationOptions } from './prompt/yaml-generator';
 export type { ChatCompletionMessageParam } from 'openai/resources/index';
 export { AiLocateElement, AiExtractElementInfo, AiLocateSection, AiJudgeOrderSensitive, } from './inspect';
+export { getModelRuntime } from './models';
+export type { ModelRuntime } from './models';
 export { plan } from './llm-planning';
 export { autoGLMPlanning } from './auto-glm/planning';
 export { adaptBboxToRect } from '../common';

package/dist/types/ai-model/model-adapter/chat-completion.d.ts

@@ -0,0 +1,2 @@
+import type { ChatCompletionAdapter, ModelAdapterDefinition } from './types';
+export declare function resolveChatCompletion(chatCompletion: ModelAdapterDefinition['chatCompletion']): ChatCompletionAdapter;

package/dist/types/ai-model/model-adapter/custom-planning-action.d.ts

@@ -0,0 +1,25 @@
+import type { LocateResultPoint, PixelBbox, PlanningAction } from '../../types';
+type PreNormalizedPlanningLocateParam = {
+    prompt: string;
+    point: LocateResultPoint;
+};
+export type LocateActionParam = {
+    locate: PreNormalizedPlanningLocateParam;
+};
+export type LocatePlanningAction<TType extends string> = PlanningAction<LocateActionParam> & {
+    type: TType;
+};
+export type ScrollPlanningAction = PlanningAction<LocateActionParam & {
+    distance: number;
+    direction: 'up' | 'down' | 'left' | 'right';
+}> & {
+    type: 'Scroll';
+};
+export type DragAndDropPlanningAction = PlanningAction<{
+    from: PreNormalizedPlanningLocateParam;
+    to: PreNormalizedPlanningLocateParam;
+}> & {
+    type: 'DragAndDrop';
+};
+export declare function getTapLocatedPixelBbox(actions: PlanningAction[]): PixelBbox | undefined;
+export {};

package/dist/types/ai-model/model-adapter/custom-planning-types.d.ts

@@ -0,0 +1,31 @@
+import type { PlanningAction } from '../../types';
+import type { LocateResultCodec, LocateResultCoordinates, ResolvedLocateResultCoordinates } from '../shared/model-locate-result/types';
+import type { PreparedUserPrompt } from '../shared/multimodal-prompt';
+import type { PlanOptions } from '../workflows/planning/types';
+export interface CustomPlanningInput {
+    userInstruction: PreparedUserPrompt;
+    options: PlanOptions;
+    coordinateSystem?: ResolvedLocateResultCoordinates;
+}
+interface CustomPlanningLifecycle<TParsed = unknown> {
+    messages: CustomPlanningMessageConfig<TParsed>;
+    parseResponse(rawResponse: string, input: CustomPlanningInput): TParsed;
+    transformActions(parsed: TParsed, input: CustomPlanningInput): PlanningAction[];
+    shouldContinuePlanning(parsed: TParsed, actions: PlanningAction[]): boolean;
+    buildResponseLog(parsed: TParsed, rawResponse: string): string;
+}
+export interface CustomPlanningDefinition<TParsed = unknown> extends CustomPlanningLifecycle<TParsed> {
+    coordinates: LocateResultCoordinates;
+}
+export interface ResolvedCustomPlanningDefinition<TParsed = unknown> extends CustomPlanningLifecycle<TParsed> {
+    coordinateSystem: ResolvedLocateResultCoordinates;
+    coordinateNormalizer: LocateResultCodec;
+}
+export interface CustomPlanningMessageConfig<TParsed = unknown> {
+    systemPromptPlacement: 'system-message' | 'user-message';
+    buildSystemPrompt(): string;
+    historyImageLimit?: number;
+    buildUserInstruction?: (userInstruction: string) => string;
+    buildAssistantContent?: (parsed: TParsed, rawResponse: string, input: CustomPlanningInput) => string | undefined;
+}
+export {};

package/dist/types/ai-model/model-adapter/default-insight-protocol.d.ts

@@ -0,0 +1,2 @@
+import type { InsightProtocolFactory } from './insight-protocol';
+export declare const createDefaultInsightProtocol: InsightProtocolFactory;

package/dist/types/ai-model/model-adapter/default-locate-protocol.d.ts

@@ -0,0 +1,7 @@
+import type { StandardLocateProtocol, StandardLocateProtocolContext } from './locate-protocol';
+type DefaultLocateProtocolOptions = {
+    acceptBbox2dAlias?: boolean;
+};
+export declare const createDefaultElementProtocol: ({ jsonParser }: StandardLocateProtocolContext, options?: DefaultLocateProtocolOptions) => StandardLocateProtocol;
+export declare const createDefaultSearchAreaProtocol: ({ jsonParser }: StandardLocateProtocolContext, options?: DefaultLocateProtocolOptions) => StandardLocateProtocol;
+export {};

package/dist/types/ai-model/model-adapter/default-planning-protocol.d.ts

@@ -0,0 +1,25 @@
+import { type JsonParser } from '../shared/json';
+import { type LocateResultPromptSpec } from '../shared/model-locate-result';
+import type { PlanningActionDescriptionBuildInput, PlanningActionOutputBuildInput, StandardPlanningProtocolFactory } from './planning-protocol';
+type ActionParamDescription = {
+    type: string;
+    optional?: true;
+    description?: string;
+    default?: unknown;
+    instruction?: string;
+};
+type ActionDescription = {
+    type: string;
+    description: string;
+    param?: Record<string, ActionParamDescription> | ActionParamDescription;
+    sample?: string;
+};
+export declare const buildActionDescription: ({ action, locateFieldDescription, actionOutputExample, }: PlanningActionDescriptionBuildInput) => ActionDescription;
+export declare const buildLocateFieldDescription: (promptSpec?: LocateResultPromptSpec) => string;
+export declare const buildPlanningActionOutput: ({ actionName, param, locateFields, locateResultKey, }: PlanningActionOutputBuildInput) => string;
+export declare const createMidscenePlanningActionOutputParser: (jsonParser: JsonParser) => (content: string) => {
+    param?: any;
+    type: string;
+} | null;
+export declare const createDefaultMidscenePlanningProtocol: StandardPlanningProtocolFactory;
+export {};

package/dist/types/ai-model/model-adapter/image-preprocess.d.ts

@@ -0,0 +1,30 @@
+export interface ImagePreprocessPolicy {
+    padBlockSize?: number;
+}
+export interface PreparedModelImage {
+    imageBase64: string;
+    /**
+     * Size of the image sent to the model after preprocessing. This can be larger
+     * than the original screenshot when padding is applied to satisfy model block
+     * size requirements.
+     */
+    preparedSize: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Size of the real screenshot content inside the prepared image. Pixel bboxes
+     * are parsed against `preparedSize`, then clipped to `contentSize` so padding
+     * added for the model is not treated as valid UI content.
+     */
+    contentSize: {
+        width: number;
+        height: number;
+    };
+}
+export declare function prepareModelImage(options: {
+    imageBase64: string;
+    width: number;
+    height: number;
+    policy: ImagePreprocessPolicy;
+}): Promise<PreparedModelImage>;

package/dist/types/ai-model/model-adapter/index.d.ts

@@ -0,0 +1,2 @@
+export { ResolvedModelAdapter } from './resolve';
+export type { ModelRuntime } from './types';

package/dist/types/ai-model/model-adapter/insight-protocol.d.ts

@@ -0,0 +1,24 @@
+import type { JsonParser } from '../shared/json';
+export type InsightDataOutputProtocol = {
+    /** Ordered XML tags delimiting the model-specific data output. */
+    tagNames: readonly [string, ...string[]];
+    rules: string;
+    placeholder: string;
+    buildExample: (serializedData: string) => string;
+    parse: <T>(content: string) => T;
+};
+export type InsightProtocol = {
+    responsePrefix?: string;
+    dataOutput: InsightDataOutputProtocol;
+};
+export type InsightProtocolContext = {
+    jsonParser: JsonParser;
+};
+export type InsightProtocolFactory = (context: InsightProtocolContext) => InsightProtocol;
+export type InsightProtocolDefinition = InsightProtocol | InsightProtocolFactory;
+export type InsightAdapter = {
+    protocol: InsightProtocol;
+};
+export type InsightDefinition = {
+    protocol?: InsightProtocolDefinition;
+};

package/dist/types/ai-model/model-adapter/insight.d.ts

@@ -0,0 +1,3 @@
+import type { InsightAdapter, InsightDefinition, InsightProtocol, InsightProtocolContext, InsightProtocolDefinition } from './insight-protocol';
+export declare function resolveInsightProtocol(definition: InsightProtocolDefinition | undefined, context: InsightProtocolContext): InsightProtocol;
+export declare function resolveInsight(insight: InsightDefinition | undefined, context: InsightProtocolContext): InsightAdapter;

package/dist/types/ai-model/model-adapter/locate-protocol.d.ts

@@ -0,0 +1,23 @@
+import type { JsonParser } from '../shared/json';
+import type { LocateResultPromptSpec, RawLocateValue } from '../shared/model-locate-result';
+export type ParsedLocateResponse = {
+    kind: 'located';
+    target: RawLocateValue;
+    references?: RawLocateValue[];
+    error?: string;
+} | {
+    kind: 'not-found';
+    error?: string;
+};
+export type StandardLocateProtocol = {
+    systemPromptIntroduction: string;
+    buildResponseInstructions: (locatePromptSpec: LocateResultPromptSpec) => string;
+    buildUserPrompt: (targetElementDescription: string) => string;
+    expectedJsonObjectResponse: boolean;
+    parseRawResponse: (content: string, locatePromptSpec: LocateResultPromptSpec) => ParsedLocateResponse;
+};
+export type StandardLocateProtocolContext = {
+    jsonParser: JsonParser;
+};
+export type StandardLocateProtocolFactory = (context: StandardLocateProtocolContext) => StandardLocateProtocol;
+export type StandardLocateProtocolDefinition = StandardLocateProtocol | StandardLocateProtocolFactory;

package/dist/types/ai-model/model-adapter/locate.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedCustomPlanningDefinition } from './custom-planning-types';
+import type { StandardLocateProtocolContext } from './locate-protocol';
+import type { LocateAdapter, ModelAdapterDefinition } from './types';
+export declare function resolveLocate(locate: ModelAdapterDefinition['locate'], resolvedCustomPlanner: ResolvedCustomPlanningDefinition | undefined, protocolContext: StandardLocateProtocolContext, acceptBbox2dAlias?: boolean): LocateAdapter;

package/dist/types/ai-model/model-adapter/planning-protocol.d.ts

@@ -0,0 +1,53 @@
+import type { DeviceAction, PlanningAction } from '../../types';
+import type { JsonParser } from '../shared/json';
+import type { LocateResultPromptSpec } from '../shared/model-locate-result';
+export type PlanningActionOutputBuildInput = {
+    actionName: string;
+    param: Record<string, unknown>;
+    locateFields?: string[];
+    locateResultKey?: string;
+};
+export type ParsedPlanningLocateParameter = {
+    prompt?: unknown;
+    [key: string]: unknown;
+};
+export type PlanningActionOutputProtocol = {
+    /**
+     * Ordered tag names that delimit the raw action output. The first tag must
+     * have an opening tag and the last tag must have a closing tag; self-closing
+     * boundary tags are not supported.
+     */
+    actionOutputTagNames: readonly [string, ...string[]];
+    actionOutputRules: string;
+    actionOutputPlaceholder: string;
+    buildActionOutput: (input: PlanningActionOutputBuildInput) => string;
+    parseActionOutput: (content: string, actionSpace: DeviceAction<any>[]) => PlanningAction | null;
+    parseRawLocateParameter: (value: unknown) => ParsedPlanningLocateParameter;
+};
+export type PlanningActionDescriptionBuildInput = {
+    action: DeviceAction<any>;
+    locateFieldDescription: string;
+    actionOutputExample?: string;
+};
+export type PlanningActionSpaceFormat = 'yaml' | 'jsonl';
+export type PlanningActionSpaceProtocol = {
+    title: string;
+    format: PlanningActionSpaceFormat;
+    includeActionOutputExample: boolean;
+    buildLocateFieldDescription: (locatePromptSpec?: LocateResultPromptSpec) => string;
+    buildActionDescription: (input: PlanningActionDescriptionBuildInput) => unknown;
+};
+export type StandardPlanningProtocol = {
+    responsePrefix?: string;
+    actionSpaceProtocol: PlanningActionSpaceProtocol;
+    actionOutputProtocol: PlanningActionOutputProtocol;
+};
+export type StandardPlanningProtocolContext = {
+    jsonParser: JsonParser;
+};
+/**
+ * Defined as a factory because planning response parsing may depend on the
+ * adapter's resolved JSON parser.
+ */
+export type StandardPlanningProtocolFactory = (context: StandardPlanningProtocolContext) => StandardPlanningProtocol;
+export type StandardPlanningProtocolDefinition = StandardPlanningProtocol | StandardPlanningProtocolFactory;

package/dist/types/ai-model/model-adapter/planning.d.ts

@@ -0,0 +1,6 @@
+import type { LocateResultCodec } from '../shared/model-locate-result';
+import type { CustomPlanningDefinition, ResolvedCustomPlanningDefinition } from './custom-planning-types';
+import type { StandardPlanningProtocolContext } from './planning-protocol';
+import type { ModelAdapterDefinition, PlanningAdapter } from './types';
+export declare function resolveCustomPlanningDefinition<TParsed>(config: CustomPlanningDefinition<TParsed>): ResolvedCustomPlanningDefinition<TParsed>;
+export declare function resolvePlanning(planning: ModelAdapterDefinition['planning'], resolvedCustomPlanner: ResolvedCustomPlanningDefinition | undefined, protocolContext: StandardPlanningProtocolContext, defaultLocateResultCodec?: LocateResultCodec): PlanningAdapter;

package/dist/types/ai-model/model-adapter/resolve.d.ts

@@ -0,0 +1,12 @@
+import type { InsightAdapter } from './insight-protocol';
+import type { ChatCompletionAdapter, ImagePreprocessPolicy, JsonParser, LocateAdapter, ModelAdapter, ModelAdapterDefinition, PlanningAdapter } from './types';
+export declare class ResolvedModelAdapter implements ModelAdapter {
+    readonly jsonParser: JsonParser;
+    readonly chatCompletion: ChatCompletionAdapter;
+    readonly acceptBbox2dAlias: boolean;
+    readonly imagePreprocess: ImagePreprocessPolicy;
+    readonly insight: InsightAdapter;
+    readonly planning: PlanningAdapter;
+    readonly locate: LocateAdapter;
+    constructor(config: ModelAdapterDefinition, modelFamily: string);
+}