@khorsheed/dsh-room 0.1.0

package/lib/types/adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The room's ONLY coupling point to the local-agent family's delegation
+ * facade (`proposals/closed/2026-08-18-local-agent-delegation-api.md`, M1
+ * landed as `LocalAgentRegistry.start/resume/cancel`). The TYPES come from a
+ * type-only import of the family core (drift-checked at compile time); the
+ * RUNTIME stays a probe — `ctx.get('localAgent')` plus method-existence
+ * checks — so a composition without the family degrades the CLI-member
+ * capability (structured `local-agent-unavailable` at invite, journaled
+ * `failed` runs at dispatch) while the main-agent member keeps working.
+ * @module @khorsheed/dsh-room/adapter
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { LocalAgentRegistry } from '@khorsheed/dsh-local-agent';
+/** The delegation-facade slice room consumes (the family's public M1 API). */
+export type LocalAgentFacade = Pick<LocalAgentRegistry, 'start' | 'resume' | 'cancel'> & Partial<Pick<LocalAgentRegistry, 'prepareMember' | 'isPreparedMember' | 'supportsMemberConfiguration'>>;
+/** The roster slice of the registry (older than the M1 facade). */
+export type LocalAgentRosterSlice = Pick<LocalAgentRegistry, 'roster' | 'statusOf'>;
+/**
+ * Probe the local-agent facade.
+ * @param ctx - host context.
+ * @returns the facade when `localAgent` is present and carries the full M1
+ * method set, undefined otherwise (absent core, or a pre-facade version).
+ */
+export declare function probeLocalAgent(ctx: Context): LocalAgentFacade | undefined;
+/**
+ * Probe the registry's roster slice (independent of the delegation facade:
+ * a core without M1 still serves the roster, and the invite dialog greys
+ * undispatchable providers instead of hiding them).
+ * @param ctx - host context.
+ * @returns the roster slice, or undefined.
+ */
+export declare function probeLocalAgentRoster(ctx: Context): LocalAgentRosterSlice | undefined;
+/**
+ * Extract a member's reply text from a settled run: the text blocks of its
+ * final output, joined. Non-text blocks (images etc.) are dropped — the
+ * blackboard is a text layer.
+ * @param output - the settled run's output content.
+ * @returns the reply text (empty string when the run produced no text).
+ */
+export declare function runOutputText(output: readonly ContentBlock[]): string;
+//# sourceMappingURL=adapter.d.ts.map

package/lib/types/adapter.js

@@ -0,0 +1,41 @@
+/** The methods a service must carry to quack like the facade. */
+const FACADE_METHODS = ['start', 'resume', 'cancel'];
+/**
+ * Probe the local-agent facade.
+ * @param ctx - host context.
+ * @returns the facade when `localAgent` is present and carries the full M1
+ * method set, undefined otherwise (absent core, or a pre-facade version).
+ */
+export function probeLocalAgent(ctx) {
+    const service = ctx.get('localAgent');
+    if (service === undefined || service === null)
+        return undefined;
+    return FACADE_METHODS.every(method => typeof service[method] === 'function')
+        ? service
+        : undefined;
+}
+/**
+ * Probe the registry's roster slice (independent of the delegation facade:
+ * a core without M1 still serves the roster, and the invite dialog greys
+ * undispatchable providers instead of hiding them).
+ * @param ctx - host context.
+ * @returns the roster slice, or undefined.
+ */
+export function probeLocalAgentRoster(ctx) {
+    const service = ctx.get('localAgent');
+    if (service === undefined || service === null)
+        return undefined;
+    return typeof service['roster'] === 'function' && typeof service['statusOf'] === 'function'
+        ? service
+        : undefined;
+}
+/**
+ * Extract a member's reply text from a settled run: the text blocks of its
+ * final output, joined. Non-text blocks (images etc.) are dropped — the
+ * blackboard is a text layer.
+ * @param output - the settled run's output content.
+ * @returns the reply text (empty string when the run produced no text).
+ */
+export function runOutputText(output) {
+    return output.flatMap(block => (block.type === 'text' ? [block.text] : [])).join('\n');
+}

package/lib/types/agent-setup.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Room agent lifecycle. A room IS its session's agent: the local-agent
+ * delegation facade resolves the dispatch parent through `ctx.agents.get`
+ * (live agents only — a harness hard constraint), and the main-agent member
+ * speaks through the same agent. So a room is created THROUGH the agent
+ * factory (the official `session.create` shape: session + live agent + the
+ * preset recorded on the header), and a mutating Remote on a cold room
+ * (after a host restart nothing republishes it — history reads never resume
+ * an agent) cold-resumes the agent first, composing the preset the session's
+ * log records (mirroring apiproxy's agentFor). Read-only remotes
+ * (isRoom/getState) never resume: a cold room answers from a persistence
+ * inspection instead.
+ * @module @khorsheed/dsh-room/agent-setup
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentSetup } from '@deepseek-ai/dsh-agent';
+import type AgentPresets from '@deepseek-ai/dsh-agent-preset-registry';
+import type { Session, SessionId } from '@deepseek-ai/dsh-session';
+import type { SessionInspection, SessionPersistence } from '@deepseek-ai/dsh-session-persistence';
+/**
+ * The slice of a session log the preset derivation reads. Structural rather
+ * than the rc host's deleted `PresetBearingSession`: the 0.1.2 host removed
+ * that type together with `resolveSessionPreset`.
+ */
+interface PersistedPresetSource {
+    header: {
+        agentPreset?: string | null;
+    };
+    events: readonly {
+        type: string;
+        data?: unknown;
+    }[];
+}
+/**
+ * The two preset-derivation surfaces a host may carry: the rc line exports
+ * `resolveSessionPreset`; the 0.1.2 line replaced it with the
+ * `agentPresetProjectionDefinition` unit. Probed per call, never from a
+ * version string (mirrors ankh-guard's PresetDerivationSurface).
+ */
+export interface PresetDerivationSurface {
+    agentPresetProjectionDefinition?: {
+        init(header: {
+            agentPreset?: string | null;
+        }): string | null;
+        apply(state: string | null, event: {
+            type: string;
+            data?: unknown;
+        }): string | null;
+    };
+    resolveSessionPreset?: (session: PersistedPresetSource) => string | undefined;
+}
+/**
+ * Which preset a session actually runs, newest selection winning. The 0.1.2
+ * host folds the header plus `agent-preset/selected` events through
+ * `agentPresetProjectionDefinition`; the rc host's `resolveSessionPreset` is
+ * the same fold. A host with neither yields undefined: the resume falls back
+ * to the deployment's default preset, the same outcome a preset-less session
+ * had before.
+ * @param host - the agent-presets module namespace, structurally probed.
+ * @param session - the session's header and event log.
+ * @returns the preset id, or `undefined` when the session names none.
+ */
+export declare function deriveSessionPreset(host: PresetDerivationSurface, session: PersistedPresetSource): string | undefined;
+/**
+ * Resolve the preset-registry module by name. The 0.1.7-rc.1 host renamed
+ * `@deepseek-ai/dsh-agent-presets` to `@deepseek-ai/dsh-agent-preset-registry`
+ * (the API carried over); 0.1.5/0.1.6 hosts install only the old name, and a
+ * host without preset composition installs neither — `null`, and the
+ * derivation host stays `{}`, the established no-preset degrade (the resume
+ * falls back to the deployment's default preset). A STATIC import of either
+ * name is a module-resolution failure at load on hosts installing only the
+ * other — pack-dist strips `dependencies`, so the specifier resolves against
+ * the host's install tree. Both specifiers stay static string literals so
+ * tsdown externalizes them and tsc type-checks them.
+ * @returns the module namespace, or null when neither name resolves.
+ */
+export declare function loadPresetRegistry(): Promise<unknown>;
+/**
+ * The derivation input resolved by the last preload. `{}` before it, which
+ * the derivation reads as "no preset surface" — the no-preset degrade.
+ */
+export declare function presetDerivationHost(): PresetDerivationSurface;
+/**
+ * Populate {@link presetDerivationHost} once, at apply time — every
+ * derivation happens on the resume/create paths that run after apply.
+ */
+export declare function preloadPresetDerivationHost(): Promise<void>;
+/** Test seam: drop the cached probe and host so a mocked resolution re-runs. */
+export declare function resetPresetRegistryProbeForTest(): void;
+/** The agentPresets face this package consumes (probed, never injected). */
+export type AgentPresetsProbe = Pick<AgentPresets, 'resolve' | 'mount'>;
+/**
+ * Probe the agent-presets roster.
+ * @param ctx - host context.
+ * @returns the roster slice, or undefined when the composition mounts none
+ * (the agent then composes plain — the pre-presets host behavior).
+ */
+export declare function probeAgentPresets(ctx: Context): AgentPresetsProbe | undefined;
+/** One agent's preset composition: the header-recorded id plus the setup. */
+export interface RoomAgentComposition {
+    /** Preset id to record on the creation header (absent without a roster). */
+    readonly agentPreset?: string;
+    /** Creation/resume setup mounting the preset into the agent's scope. */
+    readonly setup?: AgentSetup;
+}
+/**
+ * Compose the create/resume setup for a room session's agent, mirroring the
+ * official web path: resolve first (creation records the id on the header),
+ * then mount into the agent's scope during setup.
+ * @param ctx - host context.
+ * @param presetId - the preset to compose; undefined resolves the default.
+ * @returns the composition (empty when no presets roster is mounted).
+ */
+export declare function composeRoomAgent(ctx: Context, presetId: string | undefined): Promise<RoomAgentComposition>;
+/**
+ * The preset a room session runs, read from its log (a blank-window switch
+ * wins over the creation header — the official reconstruction rule).
+ * @param session - the live room session.
+ * @returns the preset id, or undefined when none was recorded.
+ */
+export declare function roomSessionPreset(session: Session): string | undefined;
+/** The sessionPersistence face this package consumes (probed, never injected). */
+export type SessionPersistenceProbe = Pick<SessionPersistence, 'open'>;
+/**
+ * Probe the session-persistence service.
+ * @param ctx - host context.
+ * @returns the handle-opening slice, or undefined when no backend is mounted.
+ */
+export declare function probeSessionPersistence(ctx: Context): SessionPersistenceProbe | undefined;
+/**
+ * Read a cold session's log from persistence without attaching or resuming
+ * anything (the read-only remotes' cold path). The 0.1.5 handle-based API
+ * replaced the one-shot `inspect`: open a read handle (no write ownership),
+ * read the full log, close.
+ * @param ctx - host context.
+ * @param sessionId - the persisted session.
+ * @returns the inspection, or undefined when absent/unreadable.
+ */
+export declare function inspectCold(ctx: Context, sessionId: SessionId): Promise<SessionInspection | undefined>;
+export {};
+//# sourceMappingURL=agent-setup.d.ts.map

package/lib/types/agent-setup.js

@@ -0,0 +1,145 @@
+/**
+ * Which preset a session actually runs, newest selection winning. The 0.1.2
+ * host folds the header plus `agent-preset/selected` events through
+ * `agentPresetProjectionDefinition`; the rc host's `resolveSessionPreset` is
+ * the same fold. A host with neither yields undefined: the resume falls back
+ * to the deployment's default preset, the same outcome a preset-less session
+ * had before.
+ * @param host - the agent-presets module namespace, structurally probed.
+ * @param session - the session's header and event log.
+ * @returns the preset id, or `undefined` when the session names none.
+ */
+export function deriveSessionPreset(host, session) {
+    if (host.agentPresetProjectionDefinition !== undefined) {
+        const projection = host.agentPresetProjectionDefinition;
+        let state = projection.init(session.header);
+        for (const event of session.events)
+            state = projection.apply(state, event);
+        return state ?? undefined;
+    }
+    return host.resolveSessionPreset?.(session);
+}
+let presetRegistryProbe;
+let probedHost = {};
+/**
+ * Resolve the preset-registry module by name. The 0.1.7-rc.1 host renamed
+ * `@deepseek-ai/dsh-agent-presets` to `@deepseek-ai/dsh-agent-preset-registry`
+ * (the API carried over); 0.1.5/0.1.6 hosts install only the old name, and a
+ * host without preset composition installs neither — `null`, and the
+ * derivation host stays `{}`, the established no-preset degrade (the resume
+ * falls back to the deployment's default preset). A STATIC import of either
+ * name is a module-resolution failure at load on hosts installing only the
+ * other — pack-dist strips `dependencies`, so the specifier resolves against
+ * the host's install tree. Both specifiers stay static string literals so
+ * tsdown externalizes them and tsc type-checks them.
+ * @returns the module namespace, or null when neither name resolves.
+ */
+export function loadPresetRegistry() {
+    presetRegistryProbe ??= import('@deepseek-ai/dsh-agent-preset-registry')
+        .catch(() => import('@deepseek-ai/dsh-agent-presets'))
+        .catch(() => null);
+    return presetRegistryProbe;
+}
+/**
+ * The derivation input resolved by the last preload. `{}` before it, which
+ * the derivation reads as "no preset surface" — the no-preset degrade.
+ */
+export function presetDerivationHost() {
+    return probedHost;
+}
+/**
+ * Populate {@link presetDerivationHost} once, at apply time — every
+ * derivation happens on the resume/create paths that run after apply.
+ */
+export async function preloadPresetDerivationHost() {
+    probedHost = ((await loadPresetRegistry()) ?? {});
+}
+/** Test seam: drop the cached probe and host so a mocked resolution re-runs. */
+export function resetPresetRegistryProbeForTest() {
+    presetRegistryProbe = undefined;
+    probedHost = {};
+}
+/**
+ * Probe the agent-presets roster.
+ * @param ctx - host context.
+ * @returns the roster slice, or undefined when the composition mounts none
+ * (the agent then composes plain — the pre-presets host behavior).
+ */
+export function probeAgentPresets(ctx) {
+    const service = ctx.get('agentPresets');
+    if (service === undefined || service === null)
+        return undefined;
+    return typeof service.resolve === 'function' && typeof service.mount === 'function'
+        ? service
+        : undefined;
+}
+/**
+ * Compose the create/resume setup for a room session's agent, mirroring the
+ * official web path: resolve first (creation records the id on the header),
+ * then mount into the agent's scope during setup.
+ * @param ctx - host context.
+ * @param presetId - the preset to compose; undefined resolves the default.
+ * @returns the composition (empty when no presets roster is mounted).
+ */
+export async function composeRoomAgent(ctx, presetId) {
+    const presets = probeAgentPresets(ctx);
+    if (presets === undefined)
+        return {};
+    const resolved = await presets.resolve(presetId);
+    return {
+        agentPreset: resolved.id,
+        setup: async (agentCtx) => { await presets.mount(agentCtx, resolved.id); },
+    };
+}
+/**
+ * The preset a room session runs, read from its log (a blank-window switch
+ * wins over the creation header — the official reconstruction rule).
+ * @param session - the live room session.
+ * @returns the preset id, or undefined when none was recorded.
+ */
+export function roomSessionPreset(session) {
+    return deriveSessionPreset(presetDerivationHost(), { header: session.header, events: session.snapshotEvents() });
+}
+/**
+ * Probe the session-persistence service.
+ * @param ctx - host context.
+ * @returns the handle-opening slice, or undefined when no backend is mounted.
+ */
+export function probeSessionPersistence(ctx) {
+    const service = ctx.get('sessionPersistence');
+    if (service === undefined || service === null)
+        return undefined;
+    return typeof service.open === 'function' ? service : undefined;
+}
+/**
+ * Read a cold session's log from persistence without attaching or resuming
+ * anything (the read-only remotes' cold path). The 0.1.5 handle-based API
+ * replaced the one-shot `inspect`: open a read handle (no write ownership),
+ * read the full log, close.
+ * @param ctx - host context.
+ * @param sessionId - the persisted session.
+ * @returns the inspection, or undefined when absent/unreadable.
+ */
+export async function inspectCold(ctx, sessionId) {
+    const persistence = probeSessionPersistence(ctx);
+    if (persistence === undefined)
+        return undefined;
+    try {
+        const handle = await persistence.open(sessionId, 'read');
+        try {
+            const cold = await handle.read(0);
+            return {
+                meta: structuredClone(handle.header),
+                inheritedEventCount: handle.inheritedEventCount,
+                events: [...cold.events],
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        // Unknown id, torn log, refused vocabulary: the probe answers "absent".
+        return undefined;
+    }
+}

package/lib/types/client/InviteAgentAction.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The session-header「邀请 agent」action (the `conversation.session.header.actions`
+ * list slot, every session): one quiet chip that opens the invite dialog.
+ * Inviting into a plain session PROMOTES it into a room host-side
+ * (ensureRoom); the dialog and its submit path are the same ones the members
+ * tab uses.
+ * @module @khorsheed/dsh-room/client/InviteAgentAction
+ */
+import { type ReactNode } from 'react';
+import type { InviteAgentActionProps } from './slots.ts';
+/** The header chip plus its dialog. */
+export declare function InviteAgentAction({ roomCwd, invite, listProviders, listNames, browseDirectory, modelSurface, renderHarnessModelPicker, roomChrome, sessionId, t, }: InviteAgentActionProps): ReactNode;
+//# sourceMappingURL=InviteAgentAction.d.ts.map

package/lib/types/client/InviteAgentAction.js

@@ -0,0 +1,45 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The session-header「邀请 agent」action (the `conversation.session.header.actions`
+ * list slot, every session): one quiet chip that opens the invite dialog.
+ * Inviting into a plain session PROMOTES it into a room host-side
+ * (ensureRoom); the dialog and its submit path are the same ones the members
+ * tab uses.
+ * @module @khorsheed/dsh-room/client/InviteAgentAction
+ */
+import { useEffect, useReducer, useState } from 'react';
+import { InviteDialog } from './InviteDialog.js';
+import css from './InviteAgentAction.module.css';
+/** The header chip plus its dialog. */
+export function InviteAgentAction({ roomCwd, invite, listProviders, listNames, browseDirectory, modelSurface, renderHarnessModelPicker, roomChrome, sessionId, t, }) {
+    const [open, setOpen] = useState(false);
+    const [providers, setProviders] = useState(undefined);
+    // Re-render when the criterion's inputs move (the inventory answer lands,
+    // or the current session flips the per-session verdict).
+    const [, bump] = useReducer((count) => count + 1, 0);
+    useEffect(() => roomChrome.subscribe(bump), [roomChrome]);
+    const openDialog = () => {
+        setProviders(undefined);
+        setOpen(true);
+        void listProviders().then(setProviders);
+    };
+    const submit = async (values) => {
+        // Blank optional fields are omitted, not sent (the host rejects a
+        // present-but-blank role; an absent one simply carries no preset).
+        const outcome = await invite({
+            provider: values.provider,
+            name: values.name,
+            ...values.instructions === '' ? {} : { instructions: values.instructions },
+            ...values.cwd === '' ? {} : { cwd: values.cwd },
+            ...values.firstTask === '' ? {} : { firstTask: values.firstTask },
+            ...values.model === '' ? {} : { model: values.model },
+        });
+        return outcome;
+    };
+    // M3' self-hide: the chip is the room's dev affordance — it renders only
+    // when this session's preset composition grants the room tools (or the
+    // session IS a room, or the criterion has no answer — all fail-open).
+    if (!roomChrome.show(sessionId))
+        return null;
+    return (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", className: css.trigger, "aria-label": t('action.inviteAgent'), onClick: openDialog, children: t('action.inviteAgent') }), open && (_jsx(InviteDialog, { mode: "invite", providers: providers?.providers, localAgentAvailable: providers?.localAgentAvailable ?? true, inheritedCwd: roomCwd, existingNames: listNames(), browseDirectory: browseDirectory, modelSurface: modelSurface, renderHarnessModelPicker: renderHarnessModelPicker, onSubmit: submit, onClose: () => { setOpen(false); }, t: t }))] }));
+}

package/lib/types/client/InviteDialog.d.ts

@@ -0,0 +1,90 @@
+import type { LocalAgentUi } from '@khorsheed/dsh-local-agent/client';
+/**
+ * The invite/edit dialog as a character-creation card: a self-drawn
+ * lightweight modal (overlay + centered card, Esc/overlay-click closes) with
+ * a live member-card preview beside the form — every keystroke re-renders
+ * the preview (the preview avatar stays neutral; the name-hash color joins
+ * once the member is seated), and a 🎲 dice button rolls a random
+ * game-flavored name from the pool (name-pool.ts), skipping names already
+ * on the roster. The chrome rides the official design tokens: the near-black
+ * button-primary-fill capsule is the one filled action, and no blue accent
+ * appears (see InviteDialog.module.css).
+ *
+ * Field order is primary-first: provider → 默认模型 → 称呼(+🎲) → 首个任务 →
+ * ▸ 高级设置 (role instructions + the member-level cwd, collapsed on invite —
+ * editing opens it, since editing IS changing those). The model field sits in
+ * the main form (promoted out of the drawer): the same control the provider
+ * settings cards use. Invites retain a saved provider choice, otherwise the
+ * shared picker chooses the first candidate. Edits retain member configuration.
+ * Older cores without the shared picker keep the legacy default/input fallback.
+ * The rest of the original
+ * contract is unchanged: logged-out providers grey with login guidance (an
+ * absent facade degrades the whole section to a hint), the name precheck
+ * plus the host's structured duplicate/invalid errors ride the inline error
+ * line, instructions ride the front of the member's FIRST task message
+ * (never a system-prompt channel), the cwd is a read-only display filled by
+ * the 浏览… button (the official `uiWorkspace.pickDirectory` call;
+ * empty = inherit the room session's cwd, shown as the placeholder), and
+ * edit mode diffs name/cwd/instructions/model.
+ */
+import { type ReactNode } from 'react';
+import type { MembersViewProps, RoomInviteOutcome, RoomMutationOutcome } from './slots.ts';
+import type { RoomMember, RoomProviderInfo } from '../types.ts';
+import type { LocalAgentModelInfo } from '@khorsheed/dsh-local-agent/types';
+/** The dialog's submit values (edit mode carries name/cwd/instructions/model). */
+export interface InviteDialogSubmit {
+    readonly provider: string;
+    readonly name: string;
+    readonly instructions: string;
+    readonly cwd: string;
+    readonly firstTask: string;
+    /** The delegation's invite-time model ('' = follow the harness default). */
+    readonly model: string;
+    /**
+     * The model value the edit field opened with (the member's effective model
+     * when the broker answered, else the journaled intent): the edit-mode diff
+     * baseline — a save only touches the broker/journal when the value moved.
+     */
+    readonly modelBaseline: string;
+}
+export interface InviteDialogProps {
+    readonly renderHarnessModelPicker?: LocalAgentUi['renderHarnessModelPicker'] | undefined;
+    readonly memberConfiguration?: ReactNode | undefined;
+    readonly mode: 'invite' | 'edit';
+    /** The member being edited (edit mode). */
+    readonly member?: RoomMember | undefined;
+    /** The invitable providers; undefined while loading (invite mode). */
+    readonly providers?: readonly RoomProviderInfo[] | undefined;
+    /** False = the delegation facade is absent (invite mode). */
+    readonly localAgentAvailable: boolean;
+    /** The room session's cwd (the empty-cwd placeholder, invite mode). */
+    readonly inheritedCwd?: string | undefined;
+    /** The roster's current names — the name dice never rolls one of these. */
+    readonly existingNames: readonly string[];
+    /**
+     * The 浏览… button's pick call (the official `uiWorkspace.pickDirectory`
+     * call): resolves the picked absolute path, null on cancel or when the
+     * host serves no native picking capability.
+     */
+    readonly browseDirectory: () => Promise<string | null>;
+    /**
+     * The pickable model surface of one harness (the localAgentGateway
+     * `harnessModel` read): the model row's menu vocabulary plus the default an
+     * unset field displays. Absent, the model field is a plain text input.
+     */
+    readonly modelSurface?: ((harness: string) => Promise<LocalAgentModelInfo | undefined>) | undefined;
+    /**
+     * A member's own model surface (the localAgentGateway `memberModel` read):
+     * the edit dialog's prefill and menu source — preferred over
+     * `harnessModel` for an existing member, since it carries that member's
+     * effective/source/choices. null/undefined answers keep the journaled
+     * intent as the baseline.
+     */
+    readonly memberModel?: ((childSessionId: string) => Promise<LocalAgentModelInfo | null | undefined>) | undefined;
+    readonly onSubmit: (values: InviteDialogSubmit) => Promise<RoomMutationOutcome | RoomInviteOutcome>;
+    readonly onClose: () => void;
+    readonly t: MembersViewProps['t'];
+}
+/** The invite/edit modal card. */
+export declare function InviteDialog({ mode, member, providers, localAgentAvailable, inheritedCwd, existingNames, browseDirectory, modelSurface, renderHarnessModelPicker, memberModel, memberConfiguration, onSubmit, onClose, t, }: InviteDialogProps): ReactNode;
+//# sourceMappingURL=InviteDialog.d.ts.map