@mind-harness/mh-browser 0.0.0-stage → 0.1.1

package/lib/types/service/extension.d.ts

@@ -0,0 +1,30 @@
+import type { BrowserContext, CDPSession } from 'playwright';
+/**
+ * Directory of the unpacked extension shipped with this package.
+ * Walks up from this module: sources live in `src/`, the bundle in `lib/`.
+ */
+export declare function extensionDir(): string;
+/**
+ * The extension that opens tabs and groups them. Loaded once per browser.
+ * Calls run in its service worker, which Chrome may restart.
+ */
+export declare class Extension {
+    private readonly context;
+    private readonly id;
+    private workerPage;
+    private constructor();
+    static load(context: BrowserContext, browserSession: CDPSession): Promise<Extension>;
+    /** `chrome.tabs.create` in the named window. Returns the extension's tab id. */
+    createTab(windowId: number, url: string): Promise<number>;
+    tabIdsIn(windowId: number): Promise<number[]>;
+    activate(tabId: number): Promise<void>;
+    group(tabId: number, target: {
+        groupId: number;
+    } | {
+        windowId: number;
+    }): Promise<number>;
+    styleGroup(groupId: number, title: string, color: 'blue' | 'red'): Promise<void>;
+    ungroup(tabId: number): Promise<void>;
+    private worker;
+}
+//# sourceMappingURL=extension.d.ts.map

package/lib/types/service/files.d.ts

@@ -0,0 +1,17 @@
+/** A download name with no directory segments. */
+export declare function safeFilename(name: string): string;
+/** Content-Disposition filename, otherwise the last segment of the final URL. */
+export declare function filenameFrom(disposition: string | undefined, url: string): string;
+export interface Written {
+    /** Relative to the session cwd. */
+    path: string;
+    bytes: number;
+    sha256: string;
+}
+/**
+ * Stream a body into a new file under `<cwd>/downloads`. The directory must be
+ * a real directory inside the cwd, and the file is created exclusively without
+ * following links, so nothing outside the cwd and no existing file is written.
+ */
+export declare function writeDownload(cwd: string, name: string, body: AsyncIterable<Uint8Array>): Promise<Written>;
+//# sourceMappingURL=files.d.ts.map

package/lib/types/service/invoke.d.ts

@@ -0,0 +1,31 @@
+import type { InvokeCall, InvokeSent, PageError, PageView } from '../types.ts';
+export interface SendRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    data?: string;
+    multipart?: Record<string, string | {
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    }>;
+}
+export type SendResult = {
+    kind: 'response';
+    status: number;
+    location?: string;
+    mediaType?: string;
+    body: Uint8Array;
+} | {
+    kind: 'lost';
+};
+export interface InvokeHost {
+    idleView(url: string): Promise<PageView | undefined>;
+    open(url: string): Promise<PageView | PageError>;
+    navigate(tab: string, url: string): Promise<PageView | PageError>;
+    reload(url: string, tab: string): Promise<PageView | PageError>;
+    send(request: SendRequest): Promise<SendResult>;
+    readFile(value: unknown): Promise<string>;
+}
+export declare function runInvoke(host: InvokeHost, pageUrl: string, call: InvokeCall): Promise<InvokeSent>;
+//# sourceMappingURL=invoke.d.ts.map

package/lib/types/service/service.d.ts

@@ -0,0 +1,183 @@
+import { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { BrowserConfig } from '../config.ts';
+import type { HeldPage, PresenceReceipt, PresenceRecord, PresenceSource } from '../presence/record.ts';
+import type { PendingOp } from '../presence/fold.ts';
+import type { ActAction, Download, FetchResponseBody, InvokeCall, InvokeSent, PageError, PageView, TabInfo, WaitFor } from '../types.ts';
+import { type Taken } from './control.ts';
+import { testHooks, type TestHooks } from './test-hooks.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        mhBrowser: MhBrowserService;
+    }
+}
+export type WriteTarget = {
+    root: string;
+} | {
+    denied: string;
+    code: 'SANDBOX_DENIED' | 'NO_WORKSPACE';
+};
+export interface HandBack extends Taken {
+    urls: string[];
+    note?: string;
+    page?: PageView;
+}
+/**
+ * Browser service. Launch, windows, tabs, waits, the request channel, and
+ * the current representation of each tab. Declared actions and downloads go
+ * through the request channel. Person input outside a service dispatch takes
+ * the session's browser. `act` returns a snapshot, including on a page that
+ * also has an Agent View.
+ */
+export declare class MhBrowserService extends TypertRemoteService {
+    static Config: import("@deepseek-ai/schemastery").default<BrowserConfig>;
+    private readonly windows;
+    private readonly launchOptions;
+    private context;
+    private ready;
+    private closing;
+    private relaunching;
+    private readonly crashes;
+    /** One queue per owner: a slow wait in one Session does not hold up another. */
+    private readonly queues;
+    private readonly shown;
+    private readonly book;
+    private readonly maxBytes;
+    private readonly workspaces;
+    private readonly control;
+    private readonly personTouch;
+    constructor(ctx: Context, config: BrowserConfig);
+    open(owner: string, items: {
+        url: string;
+        waitFor?: WaitFor;
+    }[], signal?: AbortSignal): Promise<(PageView | PageError)[]>;
+    view(owner: string, tab: string, signal?: AbortSignal): Promise<PageView | PageError>;
+    /** Pages whose current representation is already in the model's presence. */
+    rememberPresence(owner: string, urls: string[]): void;
+    presenceList(owner: string): HeldPage[];
+    presencePut(owner: string, urls: string[], source: PresenceSource): PresenceReceipt[];
+    presenceRemove(owner: string, urls: string[]): PresenceReceipt[];
+    /** The set the session log folds to; taken once per process. */
+    presenceLoad(owner: string, folded: {
+        pages: readonly HeldPage[];
+        removals: readonly PendingOp[];
+    }): void;
+    presenceTakeResume(owner: string): boolean;
+    /**
+     * Re-read presence pages and build the next reminder.
+     * A tab already on the address is read in place. A check that has to open
+     * one closes it before returning. Removals are included, and they cause
+     * every remaining page to be read so a page kept out by the byte budget
+     * can come back. An empty set has nothing to read and does not wait for the
+     * browser; a browser that is down makes every page absent.
+     */
+    presenceCheck(owner: string, which: readonly string[] | 'all', opts?: {
+        baseline?: boolean;
+        replaces?: boolean;
+        force?: boolean;
+        signal?: AbortSignal;
+    }): Promise<{
+        text: string;
+        record: PresenceRecord;
+    } | undefined>;
+    /**
+     * Where a download the page starts may be written: the session's writable
+     * root, or why it may not write at all.
+     */
+    noteWorkspace(owner: string, target: WriteTarget): void;
+    tabs(owner: string): TabInfo[];
+    takeClosed(owner: string): string[];
+    windowId(owner: string, tab: string): Promise<number | undefined>;
+    fetch(url: string, opts?: {
+        accept?: string;
+        ifNoneMatch?: string;
+    }): Promise<FetchResponseBody | {
+        kind: 'error';
+        reason: string;
+    }>;
+    pushPath(owner: string, tab: string, path: string): Promise<void>;
+    started(): Promise<void>;
+    [testHooks](): TestHooks;
+    act(owner: string, tab: string, action: ActAction, signal?: AbortSignal): Promise<PageView>;
+    holdHandover(owner: string, tab: string): void;
+    releaseHandover(owner: string): void;
+    /** `undefined` when no screenshot can be taken now: a dialog is open, or the page refused. */
+    capture(owner: string, tab: string, signal?: AbortSignal): Promise<Uint8Array | undefined>;
+    invoke(owner: string, page: string, call: InvokeCall, opts?: {
+        signal?: AbortSignal;
+        readFile?: (value: unknown) => Promise<string>;
+    }): Promise<InvokeSent>;
+    /**
+     * Not queued: it opens no tab, and a long body must not hold up the
+     * Session's other calls. `root` is the directory the session may write.
+     */
+    download(owner: string, url: string, root: string, signal?: AbortSignal): Promise<Download>;
+    controlOf(owner: string): 'model' | 'person';
+    /** Presence registers this. A hand-back calls it with the touched presence pages. */
+    bindPersonTouch(fn: (owner: string, urls: string[]) => void): () => void;
+    /**
+     * Give the browser to the person. The named tab stays in use until hand-back.
+     * This does not wait; the tool waits on the question card.
+     */
+    handover(owner: string, req: {
+        tab?: string;
+        reason: string;
+    }, signal?: AbortSignal): Promise<void>;
+    /** Remember the Session title for its tab group. Empty when the host has none. */
+    noteSessionTitle(owner: string, title: string): void;
+    /** Raise the window of this owner's latest tab. False when it has no tab. */
+    bringToFront(owner: string): Promise<boolean>;
+    /** The person asked to see the page this Session handed over. */
+    revealHandover(sessionId: string, signal?: AbortSignal): Promise<{
+        status: 'revealed' | 'not-handing-over' | 'no-tab';
+    }>;
+    /** The person answered. Returns the note, the operation count, and the named tab. */
+    handBack(owner: string, note?: string): Promise<HandBack>;
+    /** A stopped handover gives control back. A finished hand-back is left alone. */
+    releaseIfHeld(owner: string): void;
+    /**
+     * The person took over between turns. The next message they send is the
+     * hand-back. A handover that is still waiting on its card is not.
+     */
+    takePersonHandback(owner: string): HandBack | undefined;
+    private openOne;
+    private perform;
+    /** A file chooser the action opened. The tab stays in use until it navigates. */
+    private chooserHeld;
+    private refreshSnapshot;
+    private blockedView;
+    private goto;
+    private discover;
+    private fetchForRead;
+    private aria;
+    private pageFromShown;
+    /** Read one presence page. A tab opened only for this read is closed again. */
+    private observePresence;
+    private tabOn;
+    private refreshView;
+    private idleView;
+    /** The most recently touched idle tab on this address. */
+    private idleTabOn;
+    /** Only Session windows are capped; the person's window is theirs to close. */
+    private enforceCap;
+    private navigateOwned;
+    private navigateTab;
+    private reloadSame;
+    private sendAction;
+    private saveResponse;
+    private attachDownload;
+    private takePendingDownload;
+    private savePlaywrightDownload;
+    private applyDocumentType;
+    /** A failed launch is logged here; calls that need the browser see it as `BROWSER_UNAVAILABLE`. */
+    private launch;
+    private start;
+    private relaunch;
+    private stop;
+    private refuseIfPerson;
+    private takenOver;
+    private presenceUrls;
+    private snapshotNamed;
+    private exclusive;
+}
+//# sourceMappingURL=service.d.ts.map

package/lib/types/service/test-hooks.d.ts

@@ -0,0 +1,7 @@
+/** Key of the hooks tests use to crash the browser and reach a live page. Not exported by the package. */
+export declare const testHooks: unique symbol;
+export interface TestHooks {
+    crash(): Promise<void>;
+    page(owner: string, tab: string): unknown;
+}
+//# sourceMappingURL=test-hooks.d.ts.map

package/lib/types/service/waits.d.ts

@@ -0,0 +1,40 @@
+import type { Page } from 'playwright';
+import type { WaitFor } from '../types.ts';
+export interface LoadWait {
+    load: boolean;
+    pendingRequests: number;
+    dialog?: {
+        type: string;
+        message: string;
+    };
+}
+export interface TextWait {
+    met: 'text' | 'textGone' | 'time' | false;
+    seconds: number;
+    dialog?: {
+        type: string;
+        message: string;
+    };
+}
+export declare function assertWaitFor(waitFor: WaitFor | undefined): void;
+export interface ActionRequests {
+    /** A main-frame navigation request was among them. */
+    navigation(): boolean;
+    started(): number;
+    pending(): number;
+    /** Resolves when nothing is pending. */
+    drained(): Promise<void>;
+    stop(): void;
+}
+/** Requests the page starts from now on. Start before the action is dispatched. */
+export declare function trackActionRequests(page: Page): ActionRequests;
+/**
+ * Pause, then wait for what the action started: a navigation's load, or the
+ * requests it sent. Pause again when there were requests. A dialog ends the wait.
+ */
+export declare function settleAction(page: Page, navigated: boolean, requests: ActionRequests | undefined, signal: AbortSignal | undefined): Promise<LoadWait>;
+/** `load` is given at most five seconds unless a caller passes another limit. */
+export declare function waitForLoad(page: Page, signal: AbortSignal | undefined, timeout?: number): Promise<LoadWait>;
+/** `text` / `textGone` race; `time` alone sleeps. The cap is 30 seconds. */
+export declare function waitForText(page: Page, waitFor: WaitFor, signal: AbortSignal | undefined): Promise<TextWait>;
+//# sourceMappingURL=waits.d.ts.map

package/lib/types/service/windows.d.ts

@@ -0,0 +1,174 @@
+import type { BrowserContext, Dialog, Download, Page } from 'playwright';
+import { type OwnerId, type TabId, type TabInfo } from '../types.ts';
+export interface LiveTab {
+    id: TabId;
+    owner: OwnerId;
+    page: Page;
+    targetId: string;
+    windowId: number;
+    /** Extension tab id. Absent without a window, and on a page the content opened itself. */
+    chromeTabId: number | undefined;
+    url: string;
+    title: string;
+    touchedAt: number;
+    /** True when input, a dialog, or a handover is still on this tab. */
+    occupied: boolean;
+    /** Filled, selected, or uploaded since the last navigation. */
+    inputHeld: boolean;
+    /** An unaccepted dialog keeps the tab occupied across navigations. */
+    dialogHeld: boolean;
+    /** `browser_handover` named this tab and the person has not handed it back. */
+    handoverHeld: boolean;
+    inPresence: boolean;
+    mayHaveChanged: boolean;
+    pendingDialog: Dialog | undefined;
+    dialogWaiters: Array<(dialog: Dialog) => void>;
+    pendingDownload: Download | undefined;
+    /** Content-Type of the latest main-frame document response. */
+    documentType: string | undefined;
+    /** Status of that same response. A download-start navigation has no main document. */
+    documentStatus: number | undefined;
+}
+/**
+ * Session windows and tab ids. Ids come from one counter stored in the
+ * profile, so a restarted browser does not hand an old id to a new page.
+ * `context.newPage()` is not used: it lands in whichever window was active.
+ * With a window, tabs open through the extension and stay in one group per
+ * Session. Without a window, they open with `window.open` from a blank page.
+ */
+export declare class Windows {
+    private context;
+    private browserSession;
+    private readonly tabs;
+    private readonly byPage;
+    private nextId;
+    private readonly arrived;
+    private readonly waiters;
+    private readonly closedNotes;
+    /** One about:blank page per owner. New tabs open from it, because a modal dialog freezes its own page. */
+    private readonly openers;
+    private profileDir;
+    /** Set while a new tab is in flight. Only the page at `url` answers it. */
+    private slot;
+    /** Pages the service is sending input to. Events on them are not the person's. */
+    private readonly marks;
+    /** Ignore events briefly after a dispatch returns; the binding call arrives late. */
+    private readonly quietUntil;
+    /** Closes the service started. A person's close is not in here. */
+    private readonly serviceClose;
+    private readonly armed;
+    private readonly sessions;
+    /** Address of a tab when it closed, so a hand-back can still name it. */
+    private readonly lastUrls;
+    /** Tab creation claims the next `page` event through one slot. */
+    private creating;
+    private readonly pendingCreates;
+    private personInput;
+    private tabClosed;
+    /** Browser shutdown closes every page. That is not the person. */
+    private suppressed;
+    /** The browser has a window. New windows then pass `focus: false`. */
+    private headed;
+    /** Set when the browser has a window. Opening a tab and grouping go through it. */
+    private extension;
+    /** One tab group per Session window. */
+    private readonly groups;
+    private readonly titles;
+    /** Sessions whose handover is waiting. Their group title says so. */
+    private readonly waiting;
+    /** Pages a content tab opened itself. Their first navigation and close are not the person. */
+    private readonly popups;
+    attach(context: BrowserContext, profileDir: string, options: {
+        headed: boolean;
+    }): Promise<void>;
+    setPersonInput(fn: (owner: OwnerId, tab: TabId | undefined) => void): void;
+    onTabClosed(fn: (tab: LiveTab) => void): void;
+    /** The tab's address, or the one it had when it closed. */
+    urlOf(owner: OwnerId, id: TabId): string | undefined;
+    suppressPersonInput(): void;
+    resumePersonInput(): void;
+    beginDispatch(page: Page): void;
+    endDispatch(page: Page): void;
+    dropPages(): void;
+    list(owner: OwnerId): TabInfo[];
+    takeClosed(owner: OwnerId): string[];
+    get(owner: OwnerId, id: TabId): LiveTab | undefined;
+    touch(tab: LiveTab): void;
+    noteUrl(tab: LiveTab, url: string): void;
+    noteTitle(tab: LiveTab, title: string): void;
+    /** Navigation drops filled-input state. A dialog or handover stays occupied. */
+    onNavigated(tab: LiveTab): void;
+    markMayHaveChanged(tab: LiveTab): void;
+    holdDialog(tab: LiveTab, dialog?: Dialog): void;
+    clearDialog(tab: LiveTab): void;
+    holdInput(tab: LiveTab): void;
+    holdHandover(tab: LiveTab): void;
+    releaseHandover(owner: OwnerId): void;
+    /** The dialog already open, or the next one. `cancel` drops the waiter. */
+    nextDialog(tab: LiveTab): {
+        dialog: Promise<Dialog>;
+        cancel(): void;
+    };
+    /** The tab touched most recently, for raising the window the person asked to see. */
+    latest(owner: OwnerId): LiveTab | undefined;
+    /** Make this tab the current one in its window. Does not raise the browser. */
+    activate(tab: LiveTab): Promise<void>;
+    /** Group title for the person. Empty until a title is known. */
+    setTitle(owner: OwnerId, title: string): void;
+    /** A handover in progress prefixes the group title and recolors it. */
+    markWaiting(owner: OwnerId, on: boolean): void;
+    windowId(owner: OwnerId, id: TabId): Promise<number | undefined>;
+    /**
+     * A blank page in this owner's window. With a window, the first page uses
+     * `Target.createTarget({ newWindow: true, focus: false })` and later pages
+     * use the extension. Without a window, later pages use `window.open` from
+     * an isolated world so they stay in that window.
+     */
+    openBlank(owner: OwnerId): Promise<LiveTab>;
+    private createTab;
+    private keep;
+    /** Close one tab the service opened for a presence check. */
+    closeTab(tab: LiveTab, note: string): Promise<void>;
+    closeOwner(owner: OwnerId): Promise<void>;
+    private closePage;
+    /** A tab leaves the registry. The window closes with its last tab. */
+    private forget;
+    private closeOpener;
+    /** Close least-recently touched idle tabs until the owner is within the cap. */
+    enforceCap(owner: OwnerId): Promise<void>;
+    private owned;
+    private remember;
+    private allocate;
+    private openerFor;
+    private openWindow;
+    /** Headed windows pass `focus: false`. A browser that rejects it is opened without the flag. */
+    private createWindowTarget;
+    private openTabIn;
+    /**
+     * Wait for the page that arrives at a one-off blank address. Only that page
+     * answers the claim: a page the content opens meanwhile goes to its opener.
+     * The address goes back to `about:blank` without navigating.
+     */
+    private claimBlank;
+    /** The extension's id for the only tab in a window just opened. */
+    private extensionTabIn;
+    /** Ask the extension to open a blank tab in `windowId`, and claim it. */
+    private openTabViaExtension;
+    /** Put a Session's tab in its group. The person's window is not a Session and stays ungrouped. */
+    private groupTab;
+    private applyGroupStyle;
+    private ingest;
+    private adopt;
+    /**
+     * Listen for the person's pointer and keys in an isolated world.
+     * The page's own scripts cannot see the binding. A main-frame navigation
+     * or a close the service did not start counts as well. A page the content
+     * tab opened itself is not counted for its first navigation or its close.
+     */
+    private arm;
+    private report;
+    private waitForTarget;
+    private targetIdOf;
+    private windowIdOf;
+}
+//# sourceMappingURL=windows.d.ts.map

package/lib/types/tools/act.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+export declare function browserActTool(ctx: Context): ToolDefinition;
+//# sourceMappingURL=act.d.ts.map

package/lib/types/tools/attachments.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
+interface SeenRef {
+    kind: 'file' | 'image';
+    ref: Record<string, unknown>;
+}
+/** Attachment references that appeared in this session, by id. Plain JSON: a session projection state. */
+export interface AttachmentState {
+    refs: Record<string, SeenRef>;
+}
+export declare function initAttachments(): AttachmentState;
+/** Attachments reach the model in user messages and tool results. */
+export declare function applyAttachments(state: AttachmentState, event: {
+    type: string;
+    data: unknown;
+}): AttachmentState;
+/**
+ * Host paths for upload values. A value naming an attachment that appeared in
+ * this session resolves through the attachment provider; anything else is a
+ * path that must resolve inside the session cwd.
+ */
+export declare function uploadPaths(ctx: Context, seen: AttachmentState, cwd: string | undefined, values: readonly unknown[]): Promise<string[]>;
+export {};
+//# sourceMappingURL=attachments.d.ts.map

package/lib/types/tools/delivery.d.ts

@@ -0,0 +1,64 @@
+import type { SeenView } from '../types.ts';
+/** A page the session has shown the model, folded from the session log. */
+export interface Delivery {
+    url: string;
+    seq: number;
+    digest?: string;
+    /** The `version` its Agent View declares, when it declares one. */
+    version?: string;
+    /** The `id` its Agent View declares. A log written before it was recorded has none. */
+    id?: string;
+    callId?: string;
+    /** Cleared once a prune shadows it, the surface replaces it, or a summary compacts it. */
+    inContext: boolean;
+    kind: 'tool' | 'presence';
+}
+/** What the model was shown in this session. Plain JSON: it is a session projection state. */
+export interface DeliveryState {
+    deliveries: Delivery[];
+    /** Whole URLs written in delivered text, as written, trimmed, and with `&` decoded. */
+    tokens: string[];
+}
+export interface LogEvent {
+    seq: number;
+    type: string;
+    data: unknown;
+    surfaceOp?: unknown;
+}
+/** Every mh-browser tool result's `meta.by`; a result without it is not a delivery. */
+export declare const META_BY = "mh-browser";
+export declare const NOT_DELIVERED_REASON = "this address was not shown to you in this session";
+export declare function initDeliveries(): DeliveryState;
+/**
+ * One event folded into the delivery record. A tool result shadowed by
+ * `compaction/prune` or replaced on the surface is out of context, and its
+ * replacement is not a new delivery; a summary puts everything before it out
+ * of context, presence reminders included: the replacement baseline that
+ * follows the summary is the delivery that counts.
+ */
+export declare function applyDelivery(state: DeliveryState, event: LogEvent): DeliveryState;
+export declare function foldDeliveries(events: readonly LogEvent[]): DeliveryState;
+/**
+ * The Agent View of this address the model saw last, and whether it is still
+ * in context. A page shown only as a snapshot has no Agent View digest.
+ */
+export declare function latestSeen(state: DeliveryState, url: string): SeenView | 'not-in-context' | undefined;
+export type ResolvedPage = {
+    url: string;
+    seen: SeenView | 'not-in-context';
+} | {
+    ambiguous: string[];
+};
+/**
+ * The document `page` names: the one shown at that address, else the one whose
+ * Agent View declares that `id`. One `id` can name several documents, such as
+ * the pages of a collection; when more than one is in context and they
+ * differ, the caller must pick an address.
+ */
+export declare function resolvePage(state: DeliveryState, page: string): ResolvedPage | undefined;
+/**
+ * True when this http(s) address was shown, or appeared as a whole URL in
+ * something that was shown. A prefix of a shown URL is not that URL.
+ */
+export declare function wasDelivered(state: DeliveryState, url: string): boolean;
+//# sourceMappingURL=delivery.d.ts.map

package/lib/types/tools/download.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+export declare function browserDownloadTool(ctx: Context): ToolDefinition;
+//# sourceMappingURL=download.d.ts.map

package/lib/types/tools/handover.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+export declare function browserHandoverTool(ctx: Context): ToolDefinition;
+//# sourceMappingURL=handover.d.ts.map

package/lib/types/tools/invoke.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+export declare function browserInvokeTool(ctx: Context): ToolDefinition;
+//# sourceMappingURL=invoke.d.ts.map

package/lib/types/tools/open.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+export declare function browserOpenTool(ctx: Context): ToolDefinition;
+//# sourceMappingURL=open.d.ts.map

package/lib/types/tools/paths.d.ts

@@ -0,0 +1,3 @@
+/** Resolve upload paths and reject anything outside the session's cwd. */
+export declare function filesInWorkspace(cwd: string | undefined, files: string[]): Promise<string[]>;
+//# sourceMappingURL=paths.d.ts.map

package/lib/types/tools/presence.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+export declare function browserPresenceTool(ctx: Context): ToolDefinition;
+//# sourceMappingURL=presence.d.ts.map

package/lib/types/tools/register.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare function registerBrowserTools(ctx: Context): void;
+//# sourceMappingURL=register.d.ts.map

package/lib/types/tools/session.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { ToolRunContext } from '@deepseek-ai/dsh-tools';
+import type { WriteTarget } from '../service/service.ts';
+/** dsh shows the model only the message, so the message starts with the code. */
+export declare class BrowserToolError extends HarnessError {
+    readonly reason: string;
+    constructor(code: string, reason: string);
+}
+export declare const NO_WORKSPACE_REASON = "this session has no working directory";
+export interface ToolSession {
+    id: string;
+    cwd?: string;
+    session: Session;
+}
+/**
+ * The session of this tool call. Also records its title for the tab group.
+ * No title service, or no title yet, records an empty one.
+ */
+export declare function sessionFor(ctx: Context, exec: ToolRunContext): ToolSession;
+/** A title written after the last tool call still reaches the tab group. */
+export declare function followSessionTitles(ctx: Context): void;
+export declare function sessionOf(exec: ToolRunContext): ToolSession;
+/**
+ * Where this session may write a download. With dsh's sandbox policy loaded,
+ * its mode decides: `read-only` writes nothing, otherwise the policy's
+ * workspace root. Without it, the session cwd.
+ */
+export declare function writeTarget(ctx: Context, session: ToolSession): WriteTarget;
+export declare function rethrow(error: unknown, detail?: string): never;
+//# sourceMappingURL=session.d.ts.map