dsh-reference-anything 0.2.0

package/lib/contract.d.ts

@@ -0,0 +1,300 @@
+import { z } from 'zod';
+import type { InvocationDescriptor } from '@deepseek-ai/dsh-typert-protocol';
+export declare const workspaceEntrySchema: z.ZodReadonly<z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        directory: "directory";
+    }>;
+}, z.core.$strip>>;
+export declare const sessionCandidateSchema: z.ZodReadonly<z.ZodObject<{
+    sessionId: z.ZodString;
+    label: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const searchInputSchema: z.ZodReadonly<z.ZodObject<{
+    query: z.ZodString;
+    provider: z.ZodOptional<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>>;
+    limit: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const matchedViaSchema: z.ZodEnum<{
+    recent: "recent";
+    title: "title";
+    content: "content";
+}>;
+export declare const searchResultSchema: z.ZodReadonly<z.ZodObject<{
+    uriId: z.ZodString;
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    title: z.ZodString;
+    url: z.ZodString;
+    updatedAt: z.ZodString;
+    turnCount: z.ZodNumber;
+    partial: z.ZodBoolean;
+    syncedAt: z.ZodString;
+    matchedVia: z.ZodEnum<{
+        recent: "recent";
+        title: "title";
+        content: "content";
+    }>;
+    snippet: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const extensionStateSchema: z.ZodEnum<{
+    connected: "connected";
+    disconnected: "disconnected";
+    "profile-required": "profile-required";
+    "profile-disconnected": "profile-disconnected";
+    "daemon-offline": "daemon-offline";
+}>;
+export declare const healthSchema: z.ZodReadonly<z.ZodObject<{
+    version: z.ZodString;
+    daemon: z.ZodString;
+    pluginInstalled: z.ZodBoolean;
+    daemonRunning: z.ZodBoolean;
+    extensionConnected: z.ZodBoolean;
+    extensionState: z.ZodEnum<{
+        connected: "connected";
+        disconnected: "disconnected";
+        "profile-required": "profile-required";
+        "profile-disconnected": "profile-disconnected";
+        "daemon-offline": "daemon-offline";
+    }>;
+    extensionVersion: z.ZodOptional<z.ZodString>;
+    profileCount: z.ZodOptional<z.ZodNumber>;
+    opencliCompatible: z.ZodBoolean;
+    daemonVersion: z.ZodOptional<z.ZodString>;
+    daemonStale: z.ZodBoolean;
+    connectivityOk: z.ZodBoolean;
+    pluginVersion: z.ZodOptional<z.ZodString>;
+    adapterCommandsReady: z.ZodBoolean;
+    adapterCompatible: z.ZodBoolean;
+    versionError: z.ZodOptional<z.ZodString>;
+    daemonError: z.ZodOptional<z.ZodString>;
+    pluginError: z.ZodOptional<z.ZodString>;
+    doctorError: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const browserProfileSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    alias: z.ZodOptional<z.ZodString>;
+    connected: z.ZodBoolean;
+    isDefault: z.ZodBoolean;
+}, z.core.$strip>>;
+export declare const openCliDiscoverySchema: z.ZodReadonly<z.ZodObject<{
+    found: z.ZodBoolean;
+    executable: z.ZodString;
+    version: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const providerStatsSchema: z.ZodReadonly<z.ZodObject<{
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    conversations: z.ZodNumber;
+    lastSyncedAt: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        ready: "ready";
+        syncing: "syncing";
+        empty: "empty";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const syncStartSchema: z.ZodReadonly<z.ZodObject<{
+    providers: z.ZodArray<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>>;
+    mode: z.ZodEnum<{
+        incremental: "incremental";
+        full: "full";
+    }>;
+}, z.core.$strip>>;
+export declare const providerSyncProgressSchema: z.ZodReadonly<z.ZodObject<{
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    phase: z.ZodEnum<{
+        syncing: "syncing";
+        listing: "listing";
+        complete: "complete";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    completed: z.ZodNumber;
+    total: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const syncStatusSchema: z.ZodReadonly<z.ZodObject<{
+    jobId: z.ZodString;
+    status: z.ZodEnum<{
+        partial: "partial";
+        complete: "complete";
+        failed: "failed";
+        cancelled: "cancelled";
+        running: "running";
+    }>;
+    providers: z.ZodArray<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>>;
+    completed: z.ZodNumber;
+    total: z.ZodNumber;
+    providerProgress: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        provider: z.ZodEnum<{
+            chatgpt: "chatgpt";
+            claude: "claude";
+            gemini: "gemini";
+            deepseek: "deepseek";
+            grok: "grok";
+            kimi: "kimi";
+        }>;
+        phase: z.ZodEnum<{
+            syncing: "syncing";
+            listing: "listing";
+            complete: "complete";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        completed: z.ZodNumber;
+        total: z.ZodNumber;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const jobInputSchema: z.ZodReadonly<z.ZodObject<{
+    jobId: z.ZodString;
+}, z.core.$strip>>;
+export declare const browseInputSchema: z.ZodReadonly<z.ZodObject<{
+    query: z.ZodString;
+    provider: z.ZodOptional<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>>;
+    limit: z.ZodNumber;
+    offset: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const managedConversationSchema: z.ZodReadonly<z.ZodObject<{
+    uriId: z.ZodString;
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    title: z.ZodString;
+    url: z.ZodString;
+    updatedAt: z.ZodString;
+    turnCount: z.ZodNumber;
+    partial: z.ZodBoolean;
+    syncedAt: z.ZodString;
+    remoteMissing: z.ZodBoolean;
+}, z.core.$strip>>;
+export declare const browsePageSchema: z.ZodReadonly<z.ZodObject<{
+    items: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        uriId: z.ZodString;
+        provider: z.ZodEnum<{
+            chatgpt: "chatgpt";
+            claude: "claude";
+            gemini: "gemini";
+            deepseek: "deepseek";
+            grok: "grok";
+            kimi: "kimi";
+        }>;
+        title: z.ZodString;
+        url: z.ZodString;
+        updatedAt: z.ZodString;
+        turnCount: z.ZodNumber;
+        partial: z.ZodBoolean;
+        syncedAt: z.ZodString;
+        remoteMissing: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    total: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const deleteInputSchema: z.ZodReadonly<z.ZodObject<{
+    uriId: z.ZodString;
+}, z.core.$strip>>;
+export declare const storageStatsSchema: z.ZodReadonly<z.ZodObject<{
+    bytes: z.ZodNumber;
+    conversations: z.ZodNumber;
+    remoteMissing: z.ZodDefault<z.ZodNumber>;
+    oldAccountConversations: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const clearProviderInputSchema: z.ZodReadonly<z.ZodObject<{
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+}, z.core.$strip>>;
+export declare const clearOlderInputSchema: z.ZodReadonly<z.ZodObject<{
+    days: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const providerSyncStateSchema: z.ZodReadonly<z.ZodObject<{
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        cancelled: "cancelled";
+        running: "running";
+        idle: "idle";
+    }>;
+    lastSyncAt: z.ZodString;
+    lastCompleteScanAt: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strip>>;
+export declare const REFERENCE_ANYTHING_INVOCATIONS: readonly InvocationDescriptor[];

package/lib/contract.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { providerSchema, settingsRecordSchema } from "./wire.js";
+export const workspaceEntrySchema = z.object({ path: z.string(), kind: z.enum(['file', 'directory']) }).readonly();
+export const sessionCandidateSchema = z.object({ sessionId: z.string(), label: z.string(), cwd: z.string().optional(), createdAt: z.number() }).readonly();
+const agentLookup = { name: 'agent', wire: 'agentId', source: 'lookup', lookup: 'agent',
+    codec: { mode: 'strict', typeSymbol: '@deepseek-ai/dsh-session/types#SessionId', schema: z.string().min(1) } };
+export const searchInputSchema = z.object({
+    query: z.string(), provider: providerSchema.optional(), limit: z.number().int().min(1).max(100),
+}).readonly();
+export const matchedViaSchema = z.enum(['recent', 'title', 'content']);
+export const searchResultSchema = z.object({
+    uriId: z.string(), provider: providerSchema, title: z.string(), url: z.string(), updatedAt: z.string(),
+    turnCount: z.number().int().nonnegative(), partial: z.boolean(), syncedAt: z.string(),
+    matchedVia: matchedViaSchema, snippet: z.string().optional(),
+}).readonly();
+export const extensionStateSchema = z.enum(['connected', 'disconnected', 'profile-required', 'profile-disconnected', 'daemon-offline']);
+export const healthSchema = z.object({
+    version: z.string(), daemon: z.string(), pluginInstalled: z.boolean(),
+    daemonRunning: z.boolean(), extensionConnected: z.boolean(), extensionState: extensionStateSchema,
+    extensionVersion: z.string().optional(), profileCount: z.number().int().nonnegative().optional(),
+    opencliCompatible: z.boolean(), daemonVersion: z.string().optional(), daemonStale: z.boolean(),
+    connectivityOk: z.boolean(), pluginVersion: z.string().optional(), adapterCommandsReady: z.boolean(), adapterCompatible: z.boolean(),
+    versionError: z.string().optional(), daemonError: z.string().optional(), pluginError: z.string().optional(), doctorError: z.string().optional(),
+}).readonly();
+export const browserProfileSchema = z.object({ id: z.string(), alias: z.string().optional(), connected: z.boolean(), isDefault: z.boolean() }).readonly();
+export const openCliDiscoverySchema = z.object({
+    found: z.boolean(), executable: z.string(), version: z.string(), error: z.string().optional(),
+}).readonly();
+export const providerStatsSchema = z.object({
+    provider: providerSchema, conversations: z.number().int().nonnegative(), lastSyncedAt: z.string(),
+    status: z.enum(['ready', 'syncing', 'error', 'empty']), error: z.string().optional(),
+}).readonly();
+export const syncStartSchema = z.object({ providers: z.array(providerSchema).min(1), mode: z.enum(['incremental', 'full']) }).readonly();
+export const providerSyncProgressSchema = z.object({
+    provider: providerSchema,
+    phase: z.enum(['listing', 'syncing', 'complete', 'failed', 'cancelled']),
+    completed: z.number().int().nonnegative(), total: z.number().int().nonnegative(), error: z.string().optional(),
+}).readonly();
+export const syncStatusSchema = z.object({
+    jobId: z.string(), status: z.enum(['running', 'complete', 'partial', 'cancelled', 'failed']),
+    providers: z.array(providerSchema), provider: providerSchema.optional(), completed: z.number(), total: z.number(),
+    providerProgress: z.array(providerSyncProgressSchema), error: z.string().optional(),
+}).readonly();
+export const jobInputSchema = z.object({ jobId: z.string().min(1) }).readonly();
+export const browseInputSchema = z.object({
+    query: z.string(), provider: providerSchema.optional(),
+    limit: z.number().int().min(1).max(100), offset: z.number().int().nonnegative(),
+}).readonly();
+export const managedConversationSchema = z.object({
+    uriId: z.string(), provider: providerSchema, title: z.string(), url: z.string(), updatedAt: z.string(),
+    turnCount: z.number().int().nonnegative(), partial: z.boolean(), syncedAt: z.string(), remoteMissing: z.boolean(),
+}).readonly();
+export const browsePageSchema = z.object({
+    items: z.array(managedConversationSchema), total: z.number().int().nonnegative(),
+}).readonly();
+export const deleteInputSchema = z.object({ uriId: z.string().min(1) }).readonly();
+export const storageStatsSchema = z.object({
+    bytes: z.number().int().nonnegative(), conversations: z.number().int().nonnegative(),
+    remoteMissing: z.number().int().nonnegative().default(0), oldAccountConversations: z.number().int().nonnegative().default(0),
+}).readonly();
+export const clearProviderInputSchema = z.object({ provider: providerSchema }).readonly();
+export const clearOlderInputSchema = z.object({ days: z.number().int().min(1).max(36500) }).readonly();
+export const providerSyncStateSchema = z.object({
+    provider: providerSchema, status: z.enum(['idle', 'running', 'cancelled', 'failed']),
+    lastSyncAt: z.string(), lastCompleteScanAt: z.string(), error: z.string(),
+}).readonly();
+export const REFERENCE_ANYTHING_INVOCATIONS = [
+    descriptor('workspaceSearch', [agentLookup], strict('WorkspaceEntry[]', z.array(workspaceEntrySchema)), true),
+    descriptor('sessionSearch', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('SessionSearchInput', z.object({ query: z.string(), limit: z.number().int().min(1).max(100) }).readonly()) }], strict('SessionCandidate[]', z.array(sessionCandidateSchema)), true),
+    descriptor('search', [{ name: 'input', wire: 'input', source: 'json', codec: strict('SearchInput', searchInputSchema) }], strict('SearchResult[]', z.array(searchResultSchema)), true),
+    descriptor('health', [], strict('Health', healthSchema), true),
+    descriptor('profiles', [], strict('BrowserProfile[]', z.array(browserProfileSchema)), true),
+    descriptor('discoverOpenCli', [], strict('OpenCliDiscovery', openCliDiscoverySchema), true),
+    descriptor('installOpenCli', [], strict('OpenCliDiscovery', openCliDiscoverySchema), true),
+    descriptor('installAdapter', [], strict('Boolean', z.boolean()), true),
+    descriptor('restartDaemon', [], strict('Boolean', z.boolean()), true),
+    descriptor('stats', [], strict('ProviderStats[]', z.array(providerStatsSchema))),
+    descriptor('syncStart', [{ name: 'input', wire: 'input', source: 'json', codec: strict('SyncStart', syncStartSchema) }], strict('JobId', z.string())),
+    descriptor('syncStatus', [{ name: 'input', wire: 'input', source: 'json', codec: strict('JobInput', jobInputSchema) }], strict('SyncStatus?', syncStatusSchema.optional())),
+    descriptor('syncCancel', [{ name: 'input', wire: 'input', source: 'json', codec: strict('JobInput', jobInputSchema) }], strict('Boolean', z.boolean())),
+    descriptor('settingsGet', [], strict('Settings', settingsRecordSchema)),
+    descriptor('settingsUpdate', [{ name: 'settings', wire: 'settings', source: 'json', codec: strict('Settings', settingsRecordSchema) }], strict('Settings', settingsRecordSchema)),
+    descriptor('browse', [{ name: 'input', wire: 'input', source: 'json', codec: strict('BrowseInput', browseInputSchema) }], strict('BrowsePage', browsePageSchema), true),
+    descriptor('deleteConversation', [{ name: 'input', wire: 'input', source: 'json', codec: strict('DeleteInput', deleteInputSchema) }], strict('Boolean', z.boolean()), true),
+    descriptor('storageStats', [], strict('StorageStats', storageStatsSchema)),
+    descriptor('clearProvider', [{ name: 'input', wire: 'input', source: 'json', codec: strict('ClearProviderInput', clearProviderInputSchema) }], strict('Count', z.number().int().nonnegative()), true),
+    descriptor('clearOlder', [{ name: 'input', wire: 'input', source: 'json', codec: strict('ClearOlderInput', clearOlderInputSchema) }], strict('Count', z.number().int().nonnegative()), true),
+    descriptor('clearRemoteMissing', [], strict('Count', z.number().int().nonnegative()), true),
+    descriptor('clearOldAccounts', [], strict('Count', z.number().int().nonnegative()), true),
+    descriptor('syncStates', [], strict('ProviderSyncState[]', z.array(providerSyncStateSchema))),
+];
+function strict(type, schema) {
+    return { mode: 'strict', typeSymbol: `dsh-reference-anything#${type}`, schema };
+}
+function descriptor(method, parameters, result, cancelled = false) {
+    return {
+        id: `dsh-reference-anything#referenceAnything/${method}`,
+        service: 'referenceAnything', namespace: 'referenceAnything', method,
+        invocation: { kind: 'direct' }, parameters,
+        ...(cancelled ? { cancellation: { parameter: 'signal' } } : {}), result,
+    };
+}

package/lib/errors.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Failure classes for reference lookup, decoding, and budgeting.
+ *
+ * @module dsh-reference-anything/errors
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/** Stable, machine-routable failure classes; route on these, never on message text. */
+export type ReferenceErrorCode = 
+/** Two sources claimed the same registry id. */
+'SOURCE_DUPLICATE'
+/** A reference named a source that is not registered. */
+ | 'SOURCE_UNKNOWN'
+/** The owning source is registered but reported itself unusable. */
+ | 'SOURCE_UNAVAILABLE'
+/** The source is usable but holds no item with that id. */
+ | 'REFERENCE_NOT_FOUND'
+/** A live browser read targeted a conversation owned by another account. */
+ | 'REFERENCE_ACCOUNT_MISMATCH'
+/** The source failed while reading; its own error is the `cause`. */
+ | 'REFERENCE_READ_FAILED'
+/** The caller cancelled before the read settled. */
+ | 'REFERENCE_CANCELLED'
+/** A `dsh-ref:` URI was malformed, non-canonical, or not a reference at all. */
+ | 'REFERENCE_INVALID_URI'
+/** A continuation token is malformed or belongs to another reference. */
+ | 'REFERENCE_INVALID_CURSOR'
+/** The immutable revision pinned by a cursor aged out of retention. */
+ | 'REFERENCE_CURSOR_EXPIRED'
+/** The current task did not mention or discover this conversation. */
+ | 'CONVERSATION_REFERENCE_NOT_GRANTED'
+/** A provider cannot materialize this attachment from a stable locator. */
+ | 'ATTACHMENT_UNAVAILABLE'
+/** Provider bytes exceeded the attachment cap. */
+ | 'ATTACHMENT_TOO_LARGE'
+/** One message named more distinct references than the configured limit allows. */
+ | 'REFERENCE_TOO_MANY'
+/** A reference's fixed fields alone exceed its byte budget, so no honest partial exists. */
+ | 'REFERENCE_BUDGET_EXCEEDED'
+/** A plugin config value was outside its documented domain. */
+ | 'REFERENCE_INVALID_CONFIG'
+/** A management action conflicts with a sync job currently in flight. */
+ | 'REFERENCE_SYNC_IN_PROGRESS';
+/**
+ * Named distinctly from the global `ReferenceError` — these describe this
+ * package's references, not JavaScript bindings, and shadowing the built-in in
+ * a file that also does ordinary work would be a trap.
+ */
+export declare class ReferenceAnythingError extends HarnessError {
+    readonly code: ReferenceErrorCode;
+    /**
+     * @param message - human-readable diagnostic.
+     * @param code - stable failure class.
+     * @param options - standard error options, carrying the underlying `cause` where one exists.
+     */
+    constructor(message: string, code: ReferenceErrorCode, options?: ErrorOptions);
+}

package/lib/errors.js

@@ -0,0 +1,21 @@
+/**
+ * Failure classes for reference lookup, decoding, and budgeting.
+ *
+ * @module dsh-reference-anything/errors
+ */
+import { HarnessError } from '@deepseek-ai/dsh-llm';
+/**
+ * Named distinctly from the global `ReferenceError` — these describe this
+ * package's references, not JavaScript bindings, and shadowing the built-in in
+ * a file that also does ordinary work would be a trap.
+ */
+export class ReferenceAnythingError extends HarnessError {
+    /**
+     * @param message - human-readable diagnostic.
+     * @param code - stable failure class.
+     * @param options - standard error options, carrying the underlying `cause` where one exists.
+     */
+    constructor(message, code, options) {
+        super(message, code, options);
+    }
+}

package/lib/host.d.ts

@@ -0,0 +1,102 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { ChatProvider, SettingsRecord } from './store/spec.ts';
+import type { SyncMode } from './sync/index.ts';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+export declare class ReferenceAnythingRemote extends TypertRemoteService {
+    constructor(ctx: Context);
+    workspaceSearch(agent: Agent, signal: AbortSignal): Promise<import("./workspace.ts").WorkspaceEntry[]>;
+    sessionSearch(agent: Agent, input: {
+        query: string;
+        limit: number;
+    }, signal: AbortSignal): Promise<{
+        sessionId: string;
+        label: string;
+        cwd?: string;
+        createdAt: number;
+    }[]>;
+    search(input: {
+        query: string;
+        provider?: ChatProvider;
+        limit: number;
+    }, signal: AbortSignal): Promise<import("./sources/web-chat/index.ts").ConversationSearchResult[]>;
+    health(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliHealth>;
+    profiles(signal: AbortSignal): Promise<import("./opencli.ts").BrowserProfile[]>;
+    discoverOpenCli(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliDiscovery>;
+    installOpenCli(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliDiscovery>;
+    installAdapter(signal: AbortSignal): Promise<boolean>;
+    restartDaemon(signal: AbortSignal): Promise<boolean>;
+    stats(): import("./store/store.ts").ProviderStats[];
+    syncStart(input: {
+        providers: ChatProvider[];
+        mode: SyncMode;
+    }): string;
+    syncStatus(input: {
+        jobId: string;
+    }): import("./sync/index.ts").SyncJobStatus | undefined;
+    syncCancel(input: {
+        jobId: string;
+    }): boolean;
+    settingsGet(): SettingsRecord;
+    settingsUpdate(settings: SettingsRecord): Promise<{
+        opencliPath: string;
+        profile: string;
+        detailConcurrency: number;
+        autoSync: boolean;
+        syncOnStartup: boolean;
+        autoSyncMinutes: number;
+        historyMode: "metadata-only" | "offline-mirror";
+        enabledProviders: ("chatgpt" | "claude" | "gemini" | "deepseek" | "grok" | "kimi")[];
+        maxReadTurns: number;
+        inputRenderMode: "pill" | "raw-text";
+        picker?: {
+            commands: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+            };
+            skills: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+            };
+            files: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+            };
+            sessions: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+            };
+            conversations: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+            };
+        } | undefined;
+    }>;
+    browse(input: {
+        query: string;
+        provider?: ChatProvider;
+        limit: number;
+        offset: number;
+    }, signal: AbortSignal): {
+        items: import("./sources/web-chat/index.ts").ManagedConversation[];
+        total: number;
+    };
+    deleteConversation(input: {
+        uriId: string;
+    }, signal: AbortSignal): Promise<boolean>;
+    storageStats(): import("./store/store.ts").StorageStats;
+    clearProvider(input: {
+        provider: ChatProvider;
+    }, signal: AbortSignal): Promise<number>;
+    clearOlder(input: {
+        days: number;
+    }, signal: AbortSignal): Promise<number>;
+    clearRemoteMissing(signal: AbortSignal): Promise<number>;
+    clearOldAccounts(signal: AbortSignal): Promise<number>;
+    syncStates(): import("./store/store.ts").ProviderSyncState[];
+}

package/lib/host.js

@@ -0,0 +1,55 @@
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { encodeSessionReferenceUri } from '@deepseek-ai/dsh-session-reference';
+import { indexWorkspace } from "./workspace.js";
+export class ReferenceAnythingRemote extends TypertRemoteService {
+    constructor(ctx) { super(ctx, 'referenceAnything'); }
+    workspaceSearch(agent, signal) { return indexWorkspace(agent, signal); }
+    async sessionSearch(agent, input, signal) {
+        const rows = await this.ctx.sessionReferenceResolver.listCandidates(agent, input.query, input.limit, signal);
+        return rows.map(row => ({ ...row, sessionId: encodeSessionReferenceUri(row.sessionId) }));
+    }
+    search(input, signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.search(input.query, input.provider, input.limit, signal);
+    }
+    health(signal) { return this.ctx.referenceChatHistory.health(signal); }
+    profiles(signal) { return this.ctx.referenceChatHistory.profiles(signal); }
+    discoverOpenCli(signal) { return this.ctx.referenceChatHistory.discoverOpenCli(signal); }
+    installOpenCli(signal) { return this.ctx.referenceChatHistory.installOpenCli(signal); }
+    installAdapter(signal) { return this.ctx.referenceChatHistory.installAdapter(signal); }
+    restartDaemon(signal) { return this.ctx.referenceChatHistory.restartDaemon(signal); }
+    stats() { return this.ctx.referenceChatHistory.stats(); }
+    syncStart(input) {
+        return this.ctx.referenceChatHistory.sync.start(input.providers, input.mode);
+    }
+    syncStatus(input) { return this.ctx.referenceChatHistory.sync.status(input.jobId); }
+    syncCancel(input) { return this.ctx.referenceChatHistory.sync.cancel(input.jobId); }
+    settingsGet() { return this.ctx.referenceChatHistory.getSettings(); }
+    settingsUpdate(settings) { return this.ctx.referenceChatHistory.updateSettings(settings); }
+    browse(input, signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.browse(input.query, input.provider, input.limit, input.offset);
+    }
+    deleteConversation(input, signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.remove(input.uriId);
+    }
+    storageStats() { return this.ctx.referenceChatHistory.storageStats(); }
+    clearProvider(input, signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.removeProvider(input.provider);
+    }
+    clearOlder(input, signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.removeOlderThan(input.days);
+    }
+    clearRemoteMissing(signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.removeRemoteMissing();
+    }
+    clearOldAccounts(signal) {
+        signal.throwIfAborted();
+        return this.ctx.referenceChatHistory.removeOldAccounts();
+    }
+    syncStates() { return this.ctx.referenceChatHistory.syncStates(); }
+}