@huanlin/dsh-focus-chat 0.1.23

package/lib/types/client/view/rows/ContextRow.d.ts

@@ -0,0 +1,22 @@
+import type { MarkdownLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+/** Logged context-injection row (the chat ContextInjectionRow chrome: header, source, form body). */
+export declare const ContextRow: import("react").MemoExoticComponent<({ item, t, mdLabels }: {
+    item: Extract<FocusFlowItem, {
+        kind: "message";
+    }>;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+}) => import("react").JSX.Element>;
+/** One running turn's context batch: consecutive context injections under a
+ *  single collapsed line (the completed turn folds them into the turn fold
+ *  instead; expanding here reveals the individual ContextRows). */
+export declare const ContextFoldRow: import("react").MemoExoticComponent<({ item, t, mdLabels }: {
+    item: Extract<FocusFlowItem, {
+        kind: "context-fold";
+    }>;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+}) => import("react").JSX.Element>;
+/** User / steering bubble row (the chat UserStyleBubble chrome: image gallery, chips, clock, copy). */

package/lib/types/client/view/rows/FlowRow.d.ts

@@ -0,0 +1,20 @@
+import type { MarkdownLabels, MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+import { type ImageLoader } from '../chrome/MessageImage.tsx';
+import type { FocusFeedbackActions } from '../chrome/MessageFeedbackActions.tsx';
+export declare const FlowRow: import("react").MemoExoticComponent<({ item, t, mdLabels, openFile, forkAt, mentionsByKey, loadImage, feedback, isLoopback }: {
+    item: FocusFlowItem;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+    openFile: (path: string) => void;
+    forkAt: (seq: number) => void;
+    /** Inline file-mention vocabulary per assistant node key (closing prose). */
+    mentionsByKey: ReadonlyMap<string, MarkdownFileMentions | undefined>;
+    loadImage: ImageLoader;
+    /** Per-message feedback verbs (the assistant-actions strip's business face). */
+    feedback: FocusFeedbackActions;
+    isLoopback: boolean;
+}) => import("react").JSX.Element | null>;
+/** Stable React key for one flow item. */
+export declare function flowKey(item: FocusFlowItem): string;

package/lib/types/client/view/rows/RemoteTurnRow.d.ts

@@ -0,0 +1,33 @@
+import type { MarkdownLabels, MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+import { type TurnSlice } from '../../model/turn-slice.ts';
+import type { ImageLoader } from '../chrome/MessageImage.tsx';
+import type { FocusFeedbackActions } from '../chrome/MessageFeedbackActions.tsx';
+/**
+ * One completed pre-window turn: the opening user bubbles, the fold line (the
+ * local turn fold's exact chrome), and the closing reply rendered as a real
+ * assistant row from the Host index's carried message. A boundary turn — its
+ * closing still inside the window — keeps the real closing reply and turn tail
+ * rendered from the window rows below the fold instead. Expanding fetches the
+ * turn's event slice through the injected callback and renders the projected
+ * rows — the same FlowRow/TurnTailRow chrome the window flow draws. A failed
+ * fetch surfaces inline with a retry.
+ */
+export declare const RemoteTurnRow: import("react").MemoExoticComponent<({ item, slice, onExpand, t, mdLabels, openFile, forkAt, mentionsByKey, loadImage, feedback, isLoopback, }: {
+    item: Extract<FocusFlowItem, {
+        kind: "remote-turn";
+    }>;
+    /** The cached projection for this turn; absent until first expansion. */
+    slice: TurnSlice | undefined;
+    /** Fetch, project, and cache this turn's slice; resolves when cached. */
+    onExpand: (turn: number) => Promise<void>;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+    openFile: (path: string) => void;
+    forkAt: (seq: number) => void;
+    mentionsByKey: ReadonlyMap<string, MarkdownFileMentions | undefined>;
+    loadImage: ImageLoader;
+    feedback: FocusFeedbackActions;
+    isLoopback: boolean;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/RetryRow.d.ts

@@ -0,0 +1,10 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+export declare const RetryRow: import("react").MemoExoticComponent<({ item, t }: {
+    item: Extract<FocusFlowItem, {
+        kind: "retry";
+    }>;
+    t: FocusTranslate;
+}) => import("react").JSX.Element>;
+/** One completed turn's work line: every intermediate assistant row and tool
+ *  run folded under `工作了 X 分 Y 秒`, expandable back to the full rows. */

package/lib/types/client/view/rows/SystemPromptRow.d.ts

@@ -0,0 +1,12 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+/**
+ * One complete system prompt as a collapsed disclosure (the official
+ * SystemPromptRow chrome: browse icon, "System prompt" title, and an
+ * expanded body holding the full model-visible prompt text with its real
+ * line breaks).
+ */
+export declare const SystemPromptRow: import("react").MemoExoticComponent<({ text, t }: {
+    /** Complete model-visible prompt text. */
+    text: string;
+    t: FocusTranslate;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/ThinkRow.d.ts

@@ -0,0 +1,16 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+/**
+ * One Think disclosure, mirroring the chat reasoning row: the first line
+ * once settled; while the reasoning is the streaming tail the collapsed row
+ * grows a four-line end-following preview under the header — the height
+ * animates open and shut, and the running sweep washes the whole segment;
+ * the body expands on click.
+ */
+export declare const ThinkRow: import("react").MemoExoticComponent<({ text, running, title, t }: {
+    text: string;
+    /** Whether the reasoning is still the streaming tail. */
+    running: boolean;
+    /** Row title: the plain Think label, or the duration for a standalone row. */
+    title: string;
+    t: FocusTranslate;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/ToolCallRow.d.ts

@@ -0,0 +1,8 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusToolRow } from '../../model/types.ts';
+/** One Tool call row inside an expanded group: the chat ToolRow chrome (title · summary, cards, IN/OUT). */
+export declare const ToolCallRow: import("react").MemoExoticComponent<({ row, t, openFile }: {
+    row: FocusToolRow;
+    t: FocusTranslate;
+    openFile: (path: string) => void;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/ToolGroupRow.d.ts

@@ -0,0 +1,11 @@
+import type { MarkdownLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusToolGroup } from '../../model/types.ts';
+/** One folded run of Tool calls: the step-summary line with its metrics. */
+export declare const ToolGroupRow: import("react").MemoExoticComponent<({ group, t, mdLabels, openFile }: {
+    group: FocusToolGroup;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+    openFile: (path: string) => void;
+}) => import("react").JSX.Element | null>;
+/** The chat IconActions chrome: copy, optional branch, and an optional date-aware clock. */

package/lib/types/client/view/rows/TurnFoldRow.d.ts

@@ -0,0 +1,27 @@
+import type { MarkdownLabels, MarkdownFileMentions } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+import type { ImageLoader } from '../chrome/MessageImage.tsx';
+import type { FocusFeedbackActions } from '../chrome/MessageFeedbackActions.tsx';
+/**
+ * One completed turn's work line, drawn with the official turn-process
+ * chrome: a bare label button with a trailing chevron and the l2 separator
+ * underneath — no leading icon, the official 14px/24px label type — expanding
+ * the turn's folded rows. The measurement (worked duration, stopped state)
+ * stays the focus view's reading; the turn-process node's counts ride the
+ * model.
+ */
+export declare const TurnFoldRow: import("react").MemoExoticComponent<({ item, t, mdLabels, openFile, forkAt, mentionsByKey, loadImage, feedback, isLoopback }: {
+    item: Extract<FocusFlowItem, {
+        kind: "turn-fold";
+    }>;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+    openFile: (path: string) => void;
+    forkAt: (seq: number) => void;
+    mentionsByKey: ReadonlyMap<string, MarkdownFileMentions | undefined>;
+    loadImage: ImageLoader;
+    /** Per-message feedback verbs (the assistant-actions strip's business face). */
+    feedback: FocusFeedbackActions;
+    isLoopback: boolean;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/TurnTailRow.d.ts

@@ -0,0 +1,16 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+import { type FocusFeedbackActions } from '../chrome/MessageFeedbackActions.tsx';
+/** One completed turn's footer: the measured produced-files lane and the chat actions chrome. */
+export declare const TurnTailRow: import("react").MemoExoticComponent<({ item, openFile, forkAt, feedback, t, isLoopback }: {
+    item: Extract<FocusFlowItem, {
+        kind: "turn-tail";
+    }>;
+    openFile: (path: string) => void;
+    forkAt: (seq: number) => void;
+    /** Per-message feedback verbs (the assistant-actions strip's business face). */
+    feedback: FocusFeedbackActions;
+    t: FocusTranslate;
+    isLoopback: boolean;
+}) => import("react").JSX.Element>;
+/** One Host-authoritative pending steering item (the chat pending bubble shape). */

package/lib/types/client/view/rows/TurnUsageDisclosure.d.ts

@@ -0,0 +1,9 @@
+import type { TurnTokenUsage } from '@deepseek-ai/dsh-client-ui-chat/src/client/contract/chat-nodes.ts';
+import type { FocusTranslate } from '../../contract/props.ts';
+/** Compact per-Turn usage summary with an opt-in bucket breakdown (the
+ *  official TurnUsageDisclosure chrome: data icon, summary line, and the
+ *  exact bucket list on expand). */
+export declare const TurnUsageDisclosure: import("react").MemoExoticComponent<({ usage, t }: {
+    usage: TurnTokenUsage;
+    t: FocusTranslate;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/UserBubble.d.ts

@@ -0,0 +1,18 @@
+import type { MarkdownLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusFlowItem } from '../../model/types.ts';
+import { type ImageLoader } from '../chrome/MessageImage.tsx';
+export declare const MessageRow: import("react").MemoExoticComponent<({ item, t, mdLabels, loadImage }: {
+    item: Extract<FocusFlowItem, {
+        kind: "message";
+    }>;
+    t: FocusTranslate;
+    mdLabels: MarkdownLabels;
+    loadImage: ImageLoader;
+}) => import("react").JSX.Element>;
+export declare const PendingSteeringBubble: import("react").MemoExoticComponent<({ content, t, loadImage }: {
+    content: readonly ContentBlock[];
+    t: FocusTranslate;
+    loadImage: ImageLoader;
+}) => import("react").JSX.Element>;

package/lib/types/client/view/rows/group-title.d.ts

@@ -0,0 +1,32 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+import type { FocusToolGroup } from '../../model/types.ts';
+/** The step-summary line parts (pre-casing): the thinking duration leads,
+ *  then the absorbed context count, the metric families with per-family
+ *  failure tallies, and the metric-less tool calls as a "called N tools"
+ *  segment. While the run executes the line is replaced by the running
+ *  call's own row title. */
+/** One summary-line segment: plain text plus an optional failure tally
+ *  (parentheses included) rendered in the error color. */
+export interface GroupTitleSegment {
+    text: string;
+    failed?: string | undefined;
+}
+export declare function groupTitleParts(group: FocusToolGroup, t: FocusTranslate): GroupTitleSegment[];
+/** PR67 sentence style: the first visible segment is capitalized, every
+ *  later segment starts lowercase (a no-op for the zh line). */
+export declare function caseSegments(segments: GroupTitleSegment[]): GroupTitleSegment[];
+/** One metric family's summary segment with PR67 failure semantics for the
+ *  failure-carrying families: the count reads successful calls, a mixed
+ *  family appends its failure tally (red, parentheses included), and a
+ *  family that failed outright reads its singular failed phrase or the count
+ *  with an all-failed suffix. The file families read a plain count — their
+ *  tallies are never shown. */
+export declare function metricPart(parts: GroupTitleSegment[], total: number, failed: number, family: MetricFamily, t: FocusTranslate): void;
+/** A metric family the summary line aggregates (locale key stem). */
+export type MetricFamily = 'commands' | 'edits' | 'searches';
+/** One agentic family's count segment (delegation / todo / goal / workflow /
+ *  skill / question / plan / background job): plain count, no failure tally
+ *  (the chat's family literals; the todo and goal literals drop the count). */
+export declare function agentPart(parts: GroupTitleSegment[], n: number, family: 'subagents' | 'todos' | 'goals' | 'workflows' | 'skills' | 'questions' | 'plans' | 'jobs', t: FocusTranslate): void;
+/** The count segment of one metric family, with the singular form for one. */
+export declare function countSegment(family: MetricFamily, n: number, t: FocusTranslate): string;

package/lib/types/client/view/rows/produced-fit.d.ts

@@ -0,0 +1,14 @@
+import type { FocusTranslate } from '../../contract/props.ts';
+/** Files past this stay counted but unlisted: a refactor turn must not bury the answer. */
+export declare const PRODUCED_SHOWN = 6;
+/**
+ * Select the largest prefix whose measured chips and exact remainder fit.
+ * @param available - usable width of the one-line file lane.
+ * @param gap - computed flex gap between adjacent visible items.
+ * @param chipWidths - measured widths for the candidate file chips.
+ * @param moreWidthsByShown - exact localized remainder width for each shown count.
+ * @returns Number of leading chips to render.
+ */
+export declare function fitProducedFiles(available: number, gap: number, chipWidths: readonly number[], moreWidthsByShown: readonly (number | undefined)[]): number;
+/** The exact localized overflow remainder ("+ N 个文件" / "+ N files"). */
+export declare function moreLabel(t: FocusTranslate, count: number): string;

package/lib/types/host/rpc.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Host-side RPC dispatch for the focus channel: wire validation, observation
+ * leases, and error mapping on top of {@link computeTurnIndex}. Pure function
+ * `computeTurnIndex` owns the derivation; this module owns the lease and the
+ * dispatch. The two services are declared structurally: the host- and
+ * client-connection faces cannot share one tsc program, and this module only
+ * needs the RPC registry and one exact observation read.
+ * @module dsh-focus-chat/host/rpc
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session/types';
+import type { FocusRpcValue } from '../protocol.ts';
+/** One exact observation lease over a session log (the SessionObservation face this module reads). */
+export interface FocusObservation {
+    /** The session's durable events, in seq order. */
+    readonly events: readonly SessionEvent[];
+    /** Last observed event seq, or -1 for an empty log. */
+    readonly cursor: number;
+    /** Release the lease (a prepared read holds a persistence borrow). */
+    [Symbol.dispose]: () => void;
+}
+/** The observation read face this module consumes (the SessionQueryEngine's exact read). */
+export interface FocusSessionQuery {
+    observeSession(sessionId: SessionId, options?: {
+        signal?: AbortSignal;
+        projectionMode?: 'all' | 'none';
+    }): Promise<FocusObservation>;
+}
+/** The connection face this module consumes: the RPC channel registry. */
+export interface FocusHostConnection {
+    readonly rpc: {
+        handle(channel: string, handler: (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<FocusRpcResult>): () => Promise<void>;
+    };
+}
+/** The channel's connection-generic result pair. */
+export type FocusRpcResult = {
+    readonly ok: true;
+    readonly value: FocusRpcValue;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+        readonly details: object;
+    };
+};
+/**
+ * Handle one focus channel request: observe the session under a lease, index
+ * or slice, and release the lease before answering.
+ * @param ctx - host context carrying `sessionQuery` and `connection`.
+ * @param endpoint - channel-relative endpoint name.
+ * @param payload - channel-owned request payload.
+ * @param signal - caller cancellation for this request.
+ * @returns the endpoint-owned success/error result.
+ */
+export declare function handleFocusRpc(ctx: Context, endpoint: string, payload: unknown, signal: AbortSignal): Promise<FocusRpcResult>;
+/**
+ * Register the focus RPC channel on the host connection. The registration is
+ * an effect: the caller wraps it, so plugin unload removes the channel.
+ * @param ctx - host context carrying the connection and session-query services.
+ * @returns the channel's disposer.
+ */
+export declare function registerFocusRpc(ctx: Context): () => Promise<void>;

package/lib/types/host/turn-index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Host-side turn index: one O(n) scan over the durable session log that
+ * derives every completed turn's condensed summary. Pure function — the RPC
+ * layer owns observation leases and dispatch; this module owns the derivation.
+ * @module dsh-focus-chat/host/turn-index
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
+import type { TurnSummary } from '../protocol.ts';
+/** The complete turn index over one session log. */
+export interface TurnIndex {
+    /** Completed turns in log order; a running or crash-opened turn is absent. */
+    readonly turns: readonly TurnSummary[];
+    /** Last observed event seq of the log, or -1 for an empty log. */
+    readonly cursor: number;
+}
+/** One settled `assistant/message` event reduced to the fields the flow rows render. */
+export interface ClosingMessage {
+    /** Seq of the `assistant/message` event. */
+    readonly seq: number;
+    /** Unix epoch ms of the message event. */
+    readonly time: number;
+    /** Durable message id (the per-message actions' address). */
+    readonly messageId: string;
+    /** Exact model-facing blocks of the reply. */
+    readonly content: readonly ContentBlock[];
+}
+/**
+ * Derive the turn index from one session log.
+ *
+ * Position cursor: every event between `turn/start(T)` and `turn/end(T)`
+ * belongs to turn `T` — user messages and other events without a turn field
+ * read their membership from position. Only completed turns (a matching
+ * `turn/end` was seen) enter the index: a running turn, and a turn whose
+ * start was abandoned by a later boundary, stay out. The log is append-only,
+ * so an index over a prefix of the log never invalidates.
+ * @param events - the session's durable events, in seq order.
+ * @returns one turn per completed turn, plus the log cursor.
+ */
+export declare function computeTurnIndex(events: readonly SessionEvent[]): TurnIndex;

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+/** Host loader entry for the browser-only focus-view plugin. */
+/** Provides no host-side behavior. */
+export declare function apply(): void;

package/lib/types/protocol.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Wire contract of the focus RPC channel, shared by the host and client
+ * halves (type-only: every import here is erased from both bundles).
+ *
+ * The channel rides the Connection RPC registry at `/focus-chat-api` with
+ * two endpoints:
+ *  - `focus/turnIndex`  `{ sessionId }` → `{ turns, cursor }`
+ *  - `focus/turnEvents` `{ sessionId, turn }` → `{ startSeq, endSeq, events }`
+ * @module dsh-focus-chat/protocol
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
+/**
+ * One event entry of the durable session log, serialized verbatim. The
+ * plugin-merged event vocabulary (`command/*`, `compaction/*`, `llm/retry`,
+ * `tool/code-dispatch*`, …) rides the same merge-extensible `SessionEventMap`
+ * the host wrote, so consumers read extended kinds structurally.
+ */
+export type SessionEventEntry = SessionEvent;
+/** One turn-opening user message, reduced to the durable fields the collapsed row renders. */
+export interface TurnOpeningMessage {
+    /** Seq of the `user/message` event. */
+    seq: number;
+    /** Unix epoch ms of the message event. */
+    time: number;
+    /** Constant `'user'`: the opening lane only ever collects user-source messages. */
+    role: 'user';
+    /** Exact model-facing blocks of the message. */
+    content: readonly ContentBlock[];
+}
+/** One completed turn's condensed facts, derived once per session log on the Host. */
+export interface TurnSummary {
+    /** The turn number (`turn/start` payload). */
+    turn: number;
+    /** Seq of the `turn/start` event (inclusive slice start). */
+    startSeq: number;
+    /** Seq of the `turn/end` event (inclusive slice end). */
+    endSeq: number;
+    /** Unix epoch ms of the `turn/start` event. */
+    startTime: number;
+    /** Unix epoch ms of the `turn/end` event. */
+    endTime: number;
+    /** The turn ended interrupted: the fold line reads "用户 X 后停止". */
+    stopped: boolean;
+    /** Last text-bearing assistant reply's event seq; null when the turn has none. */
+    closingSeq: number | null;
+    /** Durable message id of that reply; null when the turn has none. */
+    closingMessageId: string | null;
+    /**
+     * That reply's full durable message, carried so a turn whose rows lie beyond
+     * the loaded window still renders the real reply directly; null when the
+     * turn has none.
+     */
+    closingTime: number | null;
+    closingContent: readonly ContentBlock[] | null;
+    /** User-source messages before the turn's first assistant activity, in log order. */
+    opening: readonly TurnOpeningMessage[];
+}
+/** Payload of `focus/turnIndex`. */
+export interface TurnIndexRequest {
+    /** Non-empty logical session id. */
+    sessionId: string;
+}
+/** Result of `focus/turnIndex`: every completed turn's summary plus the log cursor. */
+export interface TurnIndexResponse {
+    /** Completed turns in log order; a running or crashed-open turn is absent. */
+    turns: readonly TurnSummary[];
+    /** Last observed event seq of the session log, or -1 for an empty log. */
+    cursor: number;
+}
+/** Payload of `focus/turnEvents`. */
+export interface TurnEventsRequest {
+    /** Non-empty logical session id. */
+    sessionId: string;
+    /** Non-negative turn number that must exist in the turn index. */
+    turn: number;
+}
+/**
+ * Result of `focus/turnEvents`: the complete durable event slice of one turn,
+ * closed interval `[startSeq..endSeq]` — boundary events, messages, chunks,
+ * tool calls and results, commands, compaction lifecycle, retries, headers.
+ */
+export interface TurnEventsResponse {
+    /** Seq of the turn's `turn/start` event. */
+    startSeq: number;
+    /** Seq of the turn's `turn/end` event. */
+    endSeq: number;
+    /** Every log event whose seq falls inside the closed interval, in seq order. */
+    events: readonly SessionEventEntry[];
+}
+/** The channel's response value union (the RPC result `value`). */
+export type FocusRpcValue = TurnIndexResponse | TurnEventsResponse;
+/** The shared RPC channel the host registers and the client calls. */
+export declare const FOCUS_RPC_CHANNEL = "/focus-chat-api";

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@huanlin/dsh-focus-chat",
+  "version": "0.1.23",
+  "description": "Claude Code-style focus view for the dsh web GUI: the conversation's condensed reading surface — tool calls folded into expandable metric summaries, chat 1:1 row chrome, and streaming think rows",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-api-remotes"
+      ],
+      "platform": "web"
+    }
+  },
+  "dshClient": {
+    "inject": [
+      "@deepseek-ai/dsh-client-locale",
+      "@deepseek-ai/dsh-client-ui-conversation",
+      "@deepseek-ai/dsh-client-ui-chat",
+      "@deepseek-ai/dsh-client-connection",
+      "@deepseek-ai/dsh-api-remotes"
+    ],
+    "platform": "web"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1",
+    "@deepseek-ai/dsh-api-remotes": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-attachment": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-connection": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-locale": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-chat": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-conversation": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-renderer": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-message-feedback": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-session": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.2-rc.1",
+    "@deepseek-ai/dsh-util-workspace-path": ">=0.1.2-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-api-remotes": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-attachment": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-connection": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-test-runtime": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-attachment": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-message-feedback": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.2-rc.1",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.1.0",
+    "@types/node": "^22.0.0",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "~18.3.0",
+    "jsdom": "^25.0.0",
+    "lightningcss": "^1.25.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3",
+    "use-sync-external-store": "1.2.0",
+    "vitest": "^4.1.8"
+  },
+  "license": "BSD-3-Clause",
+  "types": "lib/types/index.d.ts",
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts",
+    "cordis.patch.yml"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsdown",
+    "bundle": "tsdown",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf lib"
+  }
+}