dsh-agent-plugins-market 0.6.2 → 0.7.1

package/lib/types/runtime/dynamic-context.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Claude Code dynamic context injection: `` !`command` `` in a command body or
+ * skill body runs the command and the placeholder becomes its output.
+ *
+ * One pass over the original text recognizes both spellings — the inline
+ * `` !`cmd` `` (only at a line start or after whitespace, matching the authoring
+ * rule) and the multi-line ```` ```! ```` fence — and every command runs
+ * sequentially in the calling session's directory. Outputs are inserted as
+ * plain text and never re-read, so a command cannot emit another placeholder.
+ *
+ * Failure is contained per invocation rather than per placeholder: the caller
+ * aborts the whole invocation with the command's own output, so a model never
+ * reads half-injected text. Exit code 1 counts as a result for the commands
+ * whose benign outcome it is (`grep`, `rg`, `find`, `diff`, `test`, …).
+ *
+ * The shell service is reached structurally: {@link shellSeamOf} resolves it
+ * from any context, and a profile without one keeps the author's literal text.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** How long one injected command may run; the executor caps a larger request. */
+export declare const DYNAMIC_CONTEXT_TIMEOUT_MS = 120000;
+/** The requested forward cap for one injected command's stdout, in bytes. */
+export declare const DYNAMIC_CONTEXT_MAX_OUTPUT_BYTES: number;
+/** The slice of the host shell service this module uses. */
+export interface ShellSeam {
+    resolve(request: {
+        command: string;
+        workdir?: string;
+        timeoutMs?: number;
+        stdoutMaxBytes?: number;
+        signal?: AbortSignal;
+    }): unknown;
+    run(spec: unknown): Promise<ShellOutcome>;
+}
+/** The fields of one shell run this module reads. */
+export interface ShellOutcome {
+    exitCode: number | null;
+    timedOut: boolean;
+    aborted: boolean;
+    stdout: {
+        text: string;
+        truncated: boolean;
+        spillPath?: string;
+    };
+    stderr: {
+        text: string;
+        truncated: boolean;
+        spillPath?: string;
+    };
+}
+/**
+ * Resolve the host shell service from any context, whether or not the reading
+ * fiber injects `shell`.
+ *
+ * Cordis resolves `ctx.shell` by walking the reading fiber's ancestors, so a
+ * scope that does not inject the service throws `cannot get property "shell"
+ * without inject` even when a sibling fiber provides it. `ctx.get` reads the
+ * global service store instead and answers `undefined` in a profile that has
+ * no shell, which is what keeps the seam optional.
+ *
+ * @param ctx - the context the dynamic-context pass runs under.
+ * @returns the shell seam, or `undefined` when the profile provides none.
+ */
+export declare function shellSeamOf(ctx: Context): ShellSeam | undefined;
+export interface DynamicContextOptions {
+    shell: ShellSeam;
+    /** Session directory every injected command runs in. */
+    workdir?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Run every placeholder's command and return the text the model receives.
+ *
+ * @param text - author text whose `${...}` variables and arguments are already resolved.
+ * @param options - the resolved shell seam, session directory and cancellation signal.
+ * @returns the text with each placeholder replaced by its command's output.
+ * @throws when a command fails, times out or is aborted, carrying the command and its output.
+ */
+export declare function injectDynamicContext(text: string, options: DynamicContextOptions): Promise<string>;
+/** Whether this command's exit status is a result rather than a failure. */
+export declare function benignExit(exitCode: number | null, command: string): boolean;

package/lib/types/runtime/feedback-tool.d.ts

@@ -5,13 +5,16 @@
  * default true), the model can call `report_market_issue` when it concludes a
  * problem it is looking at is caused by dsh-agent-plugins-market — a failed
  * install, a misdetected source, a market UI defect the user just described.
- * The tool files a GitHub issue on the plugin repository through the GitHub
- * REST API, or falls back to appending a local JSONL record under the plugin
- * data root when no repository host context is available.
+ *
+ * Filing happens in three steps, most preferred first: the `gh` CLI when it is
+ * installed and authenticated, the GitHub REST API when the process carries a
+ * `GITHUB_TOKEN` / `GH_TOKEN`, and otherwise nothing is filed — the caller
+ * gets the complete issue text plus a prefilled "new issue" URL that is opened
+ * in the browser and handed back to the user to submit.
  *
  * The tool is deliberately narrow: the title/body must describe the problem,
- * submissions are rate-limited, and the setting switch unregisters the tool
- * on the next reconcile pass.
+ * real submissions are rate-limited, and the setting switch unregisters the
+ * tool on the next reconcile pass.
  * @module runtime/feedback-tool
  */
 import type { Context } from '@deepseek-ai/cordis';
@@ -23,8 +26,13 @@ export declare const FEEDBACK_LABEL = "agent-feedback";
 /** One accepted or rejected submission outcome, mirrored to the model. */
 export interface FeedbackOutcome {
     ok: boolean;
-    /** Where the report went: the issue URL, or the local fallback path label. */
+    /**
+     * The created issue URL, or — when nothing could file it — the prefilled
+     * "new issue" URL the user opens to submit the report themselves.
+     */
     location?: string;
+    /** The complete issue title and body; present when nothing was filed automatically. */
+    issueText?: string;
     reason?: string;
 }
 /** A structured experience report the model composes. */
@@ -36,14 +44,28 @@ export interface FeedbackReport {
     /** What actually happened (errors, wrong state, broken flow). */
     actual?: string;
 }
+/** Injectable effects, so tests never reach the network or a real browser. */
+export interface FeedbackPorts {
+    /** File the issue through the `gh` CLI; undefined when gh is missing or refused. */
+    ghIssue?: (title: string, body: string) => Promise<string | undefined>;
+    /** Open the prefilled issue page; best effort. */
+    openPage?: (url: string) => Promise<void>;
+}
+/** The public "new issue" page for one report, prefilled with title and body. */
+export declare function newIssueUrl(title: string, body: string): string;
 /**
- * Submit one experience report. Tries the GitHub issue API first (works when
- * the deployment carries a GITHUB_TOKEN / GH_TOKEN with repo scope), then
- * falls back to the local JSONL spool under `<dataRoot>/feedback/`.
+ * Submit one experience report through `gh`, then the REST API, then a
+ * prefilled issue page the user submits themselves. Only a real submission
+ * advances the burst cooldown.
  */
-export declare function submitFeedback(dataRoot: string, report: FeedbackReport, now?: number): Promise<FeedbackOutcome>;
+export declare function submitFeedback(dataRoot: string, report: FeedbackReport, now?: number, ports?: FeedbackPorts): Promise<FeedbackOutcome>;
 /** Render the model's structured report into a deterministic issue body. */
 export declare function renderFeedbackBody(report: FeedbackReport): string;
 export declare const FEEDBACK_TOOL_NAME: "report_market_issue";
-/** Register the feedback tool; returns the disposer. Undefined when the host has no tools service. */
+/**
+ * Register the feedback tool; returns the disposer. Undefined when the host has
+ * no tools service to register on — the caller turns that into a mount-path
+ * diagnostic instead of an error, since the setting can simply have no effect
+ * on this host.
+ */
 export declare function mountFeedbackTool(hostCtx: Context, dataRoot: string, t: (key: string, params?: Record<string, string>) => string): (() => void) | undefined;

package/lib/types/runtime/hooks-mounts.d.ts

@@ -9,7 +9,7 @@ export declare class HooksMountRegistry {
     private readonly live;
     private readonly fingerprints;
     private readonly temporary;
-    private queue;
+    private readonly passes;
     constructor(ctx: Context);
     /** Mount/unmount one bridge per suite to match the enabled suites exactly. */
     reconcile(enabledSuites: Suite[]): Promise<HooksMountDiagnostic[]>;

package/lib/types/runtime/host-locale.d.ts

@@ -1,13 +1,31 @@
 /** Host runtime dictionary keys (mirrored for zh and en). */
-export type HostLocaleKey = 'subagentCatalogIntro' | 'subagentCatalogUpdated' | 'subagentCatalogEmpty' | 'subagentCatalogCall' | 'subagentCatalogInherit' | 'subagentCatalogDefaultEffort' | 'commandForwardTitle' | 'commandAcknowledged' | 'userCommandSourceLabel' | 'userCommandForwardTitle' | 'userCommandAcknowledged' | 'userSkillDescription' | 'feedbackToolCardTitle';
+export type HostLocaleKey = 'subagentCatalogIntro' | 'subagentCatalogUpdated' | 'subagentCatalogEmpty' | 'subagentCatalogCall' | 'commandAcknowledged' | 'userCommandSourceLabel' | 'feedbackToolCardTitle';
 export type HostTranslate = (key: HostLocaleKey, params?: Record<string, string>) => string;
 interface ResolvedLocale {
     t: HostTranslate;
 }
 /** Resolve the active host language from settings; unknown values default to zh. */
 export declare function bindHostLocale(preference: string | undefined): HostTranslate;
-/** Read `locale.preference` from `$DSH_HOME/settings.yaml` (best effort). */
+/**
+ * Wire the host settings service as the primary locale source, replacing the
+ * `settings.yaml` fallback.
+ * @param read - reads `locale.preference` from the settings service.
+ */
+export declare function setHostLocaleSource(read: () => string | undefined): void;
+/**
+ * The persisted locale preference: the host settings document when the service
+ * is composed, else `$DSH_HOME/settings.yaml` (best effort).
+ */
 export declare function readLocalePreference(): Promise<string | undefined>;
 /** Bind a host translator against the persisted locale preference. */
 export declare function loadHostLocale(): Promise<ResolvedLocale>;
+/**
+ * Read `locale.preference` from the host settings service.
+ *
+ * The locale namespace is registered by the host's own client-locale plugin, so
+ * this reads `undefined` until that plugin mounts — which is why the caller
+ * re-binds when the service arrives rather than capturing the value once.
+ * @param settingsCtx - a context carrying the `settings` service.
+ */
+export declare function readHostLocalePreference(settingsCtx: unknown): string | undefined;
 export {};

package/lib/types/runtime/lsp-direct-config.d.ts

@@ -1,12 +1,12 @@
 import type { LspServerSpec } from '../model/types.js';
 /** The direct LSP server configuration file path. */
-export declare function lspServersPath(dataRoot: string): string;
+export declare function lspServersPath(agentsRoot: string): string;
 /** Load the user-configured LSP servers; unreadable or invalid files yield an empty table. */
-export declare function loadLspServers(dataRoot: string): Promise<{
+export declare function loadLspServers(agentsRoot: string): Promise<{
     servers: Record<string, LspServerSpec>;
     errors: string[];
 }>;
 /** Validate and persist the user-configured LSP servers; returns normalized specs. */
-export declare function saveLspServers(dataRoot: string, raw: unknown): Promise<{
+export declare function saveLspServers(agentsRoot: string, raw: unknown): Promise<{
     servers: Record<string, LspServerSpec>;
 }>;

package/lib/types/runtime/lsp-mounts.d.ts

@@ -4,11 +4,22 @@
  *
  * Mounts reconcile against the enabled-suite set exactly like the MCP mounts:
  * reconcile() unmounts rows whose suite was disabled or removed and mounts
- * rows that appeared. The host LSP package is optional at runtime — without
- * it, suites keep every other surface and the manager reports a one-line
- * `host-missing` diagnostic that does not enter the retry schedule (a missing
- * package is not a transient failure). Mount failures that can resolve after
- * user action (installing the language server executable) do retry.
+ * rows that appeared. The first wanted server also mounts the capability seam
+ * this plugin owns end to end — `ctx.lsp` and the model-facing `lsp` tool —
+ * because the dsh installation does not carry the LSP packages; the last one
+ * releases it, so a profile that never enables an LSP suite never grows the
+ * `lsp` tool.
+ *
+ * Provisioning is a property of the plugin, not of the profile: both mounts
+ * are unconditional and the version comes from this package's dependency
+ * declaration. Nothing probes whether the profile already carries a seam — a
+ * seam another layer registered comes back as a `seam-conflict` diagnostic
+ * naming the layer to remove, so the aligned copy is the only one that can run.
+ *
+ * A failure the plugin cannot fix itself (a package that is genuinely absent
+ * from the profile) reports a one-line `host-missing` diagnostic that does not
+ * enter the retry schedule. Mount failures that can resolve after user action
+ * (installing the language server executable) do retry.
  *
  * Provider identity: one `${suiteId}/${serverKey}` provider id per server, so
  * two suites declaring the same server key mount independently. Extension
@@ -17,7 +28,9 @@
  * user resolves it through per-suite surface toggles.
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { Suite } from '../model/types.js';
+import { type LegacyLspSeam } from './profile-seam.js';
+import { type PluginPathContext } from '../catalog/plugin-variables.js';
+import { type Suite } from '../model/types.js';
 export interface LspMountDiagnostic {
     suiteId: string;
     serverKey: string;
@@ -42,34 +55,77 @@ export declare function toLspServerConfig(spec: {
     initializationOptions?: unknown;
     configuration?: unknown;
 }): LspStdioServerConfig;
-/** Minimal structural shape of the dynamically imported `dsh-lsp-stdio` module. */
-interface LspStdioModule {
+/** Resolve author-written paths in one declaration before the host spawns the server. */
+export declare function expandLspServerConfig(config: LspStdioServerConfig, context: PluginPathContext): LspStdioServerConfig;
+/** Minimal structural shape of a dynamically imported host plugin module. */
+interface HostModule {
     default?: unknown;
 }
 export declare class LspMountRegistry {
     private readonly ctx;
     private readonly live;
     /** Serialize mount and unmount passes so a disable cannot race an in-flight spawn. */
-    private reconcileQueue;
-    /** Pending retry timers keyed by mount key, so a teardown can cancel them. */
+    private readonly passes;
+    /** Delayed re-attempts for mounts that are not live yet. */
     private readonly retries;
-    /** Attempt count per mount key; reset whenever a retry succeeds. */
-    private readonly attempts;
     /** Snapshot of the last reconciled suite set, replayed by retry passes. */
     private lastEnabled;
     /** Host module loader; overridable for tests. */
     private loadHost;
+    /**
+     * Reads the profile files when a seam conflict needs explaining. Injectable
+     * because it touches the machine's own `$DSH_HOME`, so a test must not
+     * inherit whatever the developer running it happens to have configured.
+     */
+    private readonly locateSeams;
+    /** `ctx.lsp` seam loader, mounted only when the profile supplies no service. */
+    private loadService;
+    /** `lsp` tool loader, mounted only when the profile publishes no such tool. */
+    private loadTool;
+    /** Capability plugins this registry mounted, in mount order, disposed with the last server. */
+    private readonly capability;
+    /** Whether the capability seam was already resolved for the current wanted set. */
+    private capabilityReady;
+    /** Why the capability seam is unavailable; re-attempted on the next reconcile pass. */
+    private capabilityFailure;
     /** Latest diagnostic per suite id; cleared when its suite mounts or leaves the wanted set. */
     private readonly lastDiagnostics;
+    /** Plugin storage root holding each suite's `${PLUGIN_DATA}` directory; unset leaves the variable verbatim. */
+    private pluginDataRoot?;
     /** Direct (user-configured) server provider; defaults to none. */
     private directProvider;
     private disabledProvider;
     private disabledSnapshot;
-    constructor(ctx: Context, loadHost?: () => Promise<LspStdioModule | undefined>);
+    constructor(ctx: Context, loadHost?: () => Promise<HostModule | undefined>, loadService?: () => Promise<HostModule | undefined>, loadTool?: () => Promise<HostModule | undefined>, locateSeams?: () => Promise<LegacyLspSeam[]>);
     /** Queue one reconciliation behind any in-flight mount/unmount pass. */
     reconcile(enabledSuites: Suite[]): Promise<LspMountDiagnostic[]>;
     /** Mount/unmount LSP servers to match the enabled suites plus direct config exactly. */
     private reconcileNow;
+    /**
+     * Mount the capability seam this plugin delivers end to end: `ctx.lsp`, then the model-facing
+     * `lsp` tool.
+     *
+     * The plugin never asks what the profile already carries. Its dependency declaration decides
+     * the version, so deferring to a seam another layer registered would silently run whatever
+     * version that layer picked. Both mounts are therefore unconditional; a seam that is already
+     * taken comes back as a `seam-conflict` diagnostic naming the layer to remove, which is the
+     * only way the aligned copy can own it.
+     * @returns the failure, or undefined when the seam is ready.
+     */
+    private ensureCapability;
+    /** Mount one capability plugin and remember it for teardown with the last server. */
+    private mountCapability;
+    /**
+     * Explain a taken seam, naming the profile layer to remove when one can be
+     * found on disk. Releases before the plugin provisioned LSP itself told users
+     * to add that layer by hand, so the message points at the exact file and rows
+     * rather than at "the profile" in general.
+     */
+    private seamConflictReason;
+    /** Dispose the capability seam this registry mounted, once no wanted server needs it. */
+    private releaseCapability;
+    /** Install the plugin storage root per-suite data directories resolve against. */
+    setPluginDataRoot(root: string): void;
     /** Install the direct (user-configured) server provider used at reconcile time. */
     setDirectProvider(provider: () => Promise<Record<string, import('../model/types.js').LspServerSpec>>): void;
     setDisabledProvider(provider: () => Promise<Set<string>>): void;
@@ -81,12 +137,6 @@ export declare class LspMountRegistry {
     /** Mount one suite's full server table as a single `dsh-lsp-stdio` instance. */
     private mountWith;
     private unmount;
-    /**
-     * Schedule a delayed re-attempt for a mount that still is not live. A
-     * `host-missing` failure passes no diagnostic and is never retried; the
-     * schedule is bounded and resets with every reconcile pass.
-     */
-    private scheduleRetry;
     /** Dispose every live mount after queued reconciliation passes settle. */
     disposeAll(): Promise<void>;
 }

package/lib/types/runtime/lsp-status.d.ts

@@ -7,7 +7,8 @@
  * so a row's state is a declaration-and-diagnostic judgment: a suite whose
  * mount succeeded yields `mounted` (the seam guarantees registration), a
  * stored diagnostic yields its own state, and a declaration with neither
- * mounts nor diagnostics means the host packages are absent (`host-missing`).
+ * mounts nor diagnostics means the capability packages could not be loaded
+ * (`host-missing`).
  * Direct user-configured rows follow the same model under the sentinel suite
  * id `direct` (mirroring mcp-status's `plugin`/`direct` split).
  */

package/lib/types/runtime/mcp-auth-record.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The credential record one MCP server's OAuth grant lives under.
+ *
+ * `runtime/mcp-client/oauth.ts` writes those records; this module addresses
+ * the same key so a grant can be dropped without waking the transport that
+ * wrote it. The scope and the name fold must stay identical to that writer's,
+ * or the delete silently misses the record.
+ *
+ * @module runtime/mcp-auth-record
+ */
+import { type CredentialKey } from './mcp-client/host-seams.js';
+/** Credential-record scope for MCP OAuth state; per-server ids follow it. */
+export declare const MCP_AUTH_RECORD_SCOPE = "mcp-auth";
+/**
+ * Fold a `serverName` into a credential-key id segment. Server names carry
+ * `__` separators (e.g. `cloudflare__cloudflare-api`), and the key grammar
+ * admits only `[a-z0-9-]`, so non-conforming characters collapse to `-` —
+ * deterministic, so the same server always reads and writes one record.
+ */
+export declare function mcpAuthRecordId(serverName: string): string;
+/** The credential record key one MCP server's OAuth grant is stored under. */
+export declare function mcpAuthRecordKey(serverName: string): CredentialKey;
+/**
+ * Drop one MCP server's OAuth grant record so the next mount re-runs the
+ * browser authorization — the path for "I picked too narrow a scope".
+ * @param store - the host credentials service, when one is mounted.
+ * @throws when the credentials service is not mounted.
+ */
+export declare function deleteMcpAuthGrant(store: unknown, serverName: string): Promise<void>;

package/lib/types/runtime/mcp-backend.d.ts

@@ -4,8 +4,8 @@
  * and legacy SSE) or through the host's `@deepseek-ai/dsh-mcp-client`
  * (compatibility mode: no OAuth, no SSE, but the host-native implementation).
  *
- * The choice is a host settings namespace (`dsh-agent-plugins-market`,
- * `mcpEnhanced: boolean`, default true) registered by the plugin's node half:
+ * The choice is the `mcpEnhanced` field of the market's host settings
+ * namespace (see `contracts/settings.ts`) registered by the plugin's node half:
  * the registration is what makes the host 插件配置 tab serve our card, the
  * client card binds it for state, and the node half watches it to remount
  * servers when the switch flips. `readMcpBackend` remains only as the
@@ -16,28 +16,24 @@
 import z from '@deepseek-ai/schemastery';
 /** The MCP mount backend the market uses for suite servers. */
 export type McpBackend = 'builtin' | 'host';
-export declare const MCP_BACKENDS: readonly McpBackend[];
-/** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
-export declare const MCP_SETTINGS_NAMESPACE = "dsh-agent-plugins-market";
-/** Schema of the market settings namespace: the MCP enhancement switch, the download region, and the feedback tool switch. */
+/**
+ * Schema of the market settings namespace: the switches this plugin's config
+ * card serves, with the defaults declared to the host. The values themselves
+ * belong to {@link MARKET_SETTINGS_DEFAULTS}; this schema states them, it does
+ * not own them.
+ */
 export declare const MarketSettingsSchema: z<Schemastery.ObjectS<{
-    /** ON (default) = the built-in bridge with OAuth and SSE; OFF = host client compat mode. */
     mcpEnhanced: z<boolean, boolean>;
-    /** Read native Agent layouts under the project root; default preserves existing discovery. */
     scanProjectLayouts: z<boolean, boolean>;
-    /** Download region for GitHub acquisition; `auto` follows the interface language. */
     downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china">;
-    /** ON (default) = the `report_market_issue` model tool is registered; OFF = unregistered. */
     feedbackEnabled: z<boolean, boolean>;
+    autoUpdateSources: z<boolean, boolean>;
 }>, Schemastery.ObjectT<{
-    /** ON (default) = the built-in bridge with OAuth and SSE; OFF = host client compat mode. */
     mcpEnhanced: z<boolean, boolean>;
-    /** Read native Agent layouts under the project root; default preserves existing discovery. */
     scanProjectLayouts: z<boolean, boolean>;
-    /** Download region for GitHub acquisition; `auto` follows the interface language. */
     downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china">;
-    /** ON (default) = the `report_market_issue` model tool is registered; OFF = unregistered. */
     feedbackEnabled: z<boolean, boolean>;
+    autoUpdateSources: z<boolean, boolean>;
 }>>;
 /** Path of the legacy persisted settings file under the plugin data root. */
 export declare function marketSettingsPath(dataRoot: string): string;

package/lib/types/runtime/mcp-client/config.d.ts

@@ -10,10 +10,16 @@
  */
 import type { ReconnectConfig } from './connection.js';
 import type { McpServerPolicy } from '../../model/types.js';
-export type { ReconnectConfig, ResolvedReconnectPolicy } from './connection.js';
-export { RECONNECT_DEFAULTS } from './connection.js';
 /** Default timeout for individual MCP tool calls (ms). */
 export declare const DEFAULT_TOOL_CALL_TIMEOUT_MS = 60000;
+/**
+ * How long one connection attempt may spend initializing (ms). A server that
+ * never answers would otherwise hold its process, transport and browser leg
+ * until the SDK's own 60-second request default expired; a working server
+ * handshakes well under a second, and a genuinely slow one can declare its own
+ * `startupTimeoutMs`.
+ */
+export declare const DEFAULT_STARTUP_TIMEOUT_MS = 10000;
 /** Valid `serverName`, kept below the public tool-name budget. */
 export declare const SERVER_NAME_PATTERN: RegExp;
 /**

package/lib/types/runtime/mcp-client/host-contract.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Structural mirrors of the harness tool-registration surface the bridge
+ * registers against: the runtime accepts the same object shape the upstream
+ * `@deepseek-ai/dsh-tools` bridge registers, so the model-facing behavior is
+ * identical. Mirrored rather than imported so the market never loads a second
+ * copy of the host runtime.
+ *
+ * @module runtime/mcp-client/host-contract
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { JsonSchemaNode } from './json-schema-subset.js';
+/** Lossless JSON value vocabulary the bridge exchanges with the registry. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Canonical MCP result exposed to Code Mode without discarding protocol blocks. */
+export type McpResult<Structured extends JsonValue = JsonValue> = {
+    content: JsonValue[];
+    structuredContent?: Structured;
+};
+/** The agent on whose behalf a tool call runs (structural mirror). */
+interface ToolExecutionAgent {
+    session?: {
+        requestHeader?: () => {
+            config?: {
+                provider?: string;
+                model?: string;
+            };
+        } | undefined;
+    };
+    options?: {
+        provider?: string;
+        model?: string;
+    };
+}
+/** Execution identity handed to a tool body (structural mirror). */
+export interface ToolExecution {
+    /** Caller-owned cancellation for this invocation. */
+    readonly signal: AbortSignal;
+    /** The calling agent, when the call came from one. */
+    readonly agent?: ToolExecutionAgent;
+}
+/** A settled tool outcome (structural mirror). */
+export interface ToolExecutionResult {
+    readonly value: JsonValue;
+    readonly content: ContentBlock[];
+    readonly isError: boolean;
+}
+/** One registered tool (structural mirror of the host registration shape). */
+export interface ToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    readonly output: {
+        readonly schema: JsonSchemaNode;
+        render(args: unknown, value: JsonValue): ContentBlock[];
+    };
+    execute(args: unknown, exec: ToolExecution): Promise<unknown>;
+    finalizeContent?(exec: Readonly<ToolExecution>, result: Readonly<ToolExecutionResult>): ContentBlock[] | undefined;
+}
+/**
+ * The host surface the bridge needs: a tool registry, a logger, and the two
+ * optional services image projection consults. Structural — the cordis
+ * context is adapted onto this shape by the bridge shell.
+ */
+export interface ToolHost {
+    readonly logger: {
+        error(message: string): void;
+        warn(message: string): void;
+        info(message: string): void;
+    };
+    readonly tools: {
+        register(definition: ToolDefinition): () => void;
+    };
+    /** Optional service lookup; image projection degrades when absent. */
+    getService?(name: 'attachments' | 'llm'): unknown;
+}
+export {};

package/lib/types/runtime/mcp-client/host-seams.d.ts

@@ -1,55 +1,25 @@
 /**
- * Local ports of the tiny host seams the self-built MCP client needs.
+ * The host seams the self-built MCP client consumes, re-exported from the
+ * packages that own them.
  *
- * The market plugin must stay self-contained at runtime: it cannot import
- * host-internal packages that are not published at compatible versions, and
- * every one of these seams is a small pure function or constant. Each port
- * below is copied verbatim (semantics, not prose) from the harness source at
- * `0.1.1-rc.2` and carries the upstream reference it came from, so a future
- * host change can be re-diffed against `~/workspace/deepseek-harness`.
+ * These are small pure functions and constants, but each one encodes a rule
+ * this plugin must obey rather than a choice it gets to make: which credential
+ * keys the host accepts, how long a timer may be, which environment names never
+ * reach a child process, and which image failures a caller can correct. Reading
+ * them from the host keeps one owner per rule, so a host change reaches this
+ * plugin instead of leaving a copy behind.
  *
- * Anything larger than a handful of lines (the JSON Schema subset validator)
- * lives in its own module.
+ * The OAuth provider and attachment admission reach their services through the
+ * optional `credentials` / `attachments` seams at runtime, so the service types
+ * here stay structural — only the rules are imported.
  *
  * @module runtime/mcp-client/host-seams
  */
-/**
- * The largest delay `setTimeout` accepts without overflowing to a 1ms clamp
- * (2^31 - 1). Shared guard for reconnect and callback timers.
- */
-export declare const MAX_TIMER_DELAY_MS = 2147483647;
-/** `DSH_*` environment namespace owned by the harness. */
-export declare const DSH_ENV_PREFIX: "DSH_";
-/**
- * Credential-shaped environment names are NOT forwarded to MCP server child
- * processes (the harness's own `DEEPSEEK_API_KEY`/secrets must not leak into a
- * spawned server implicitly). Deliberately supplied env entries survive
- * because the config's explicit env merges after the scrub.
- */
-export declare const SENSITIVE_ENV_PATTERN: RegExp;
-/**
- * The ambient parent environment minus credential-shaped names and minus all
- * `DSH_*` names — the canonical base every harness child starts from. `PATH`,
- * `HOME`, locale, and proxy variables survive, so child CLIs run normally;
- * harness identity never leaks implicitly. Both scrubs match case-insensitively:
- * Windows environment names are case-insensitive, so a parent `dsh_*` entry
- * would otherwise survive and read back as `$env:DSH_*` in the child.
- * @returns a fresh environment object safe to hand to a child spawn.
- */
-export declare function scrubbedParentEnv(): Record<string, string>;
-/** A credential record key: `<scope>/<id>` with both segments in the grammar below. */
-declare const credentialKeyBrand: unique symbol;
-export type CredentialKey = string & {
-    readonly [credentialKeyBrand]: true;
-};
-/**
- * Brand a scope and an id as a {@link CredentialKey}.
- * @param scope - the owning plugin's registered name (here: the `mcp-auth` record scope).
- * @param id - the plugin's own addressing unit (here: the folded serverName).
- * @returns the branded key.
- * @throws TypeError when either segment is not a lowercase hyphenated identifier.
- */
-export declare function credentialKey(scope: string, id: string): CredentialKey;
+import type { CredentialKey } from '@deepseek-ai/dsh-credentials';
+import type { SaveImageAttachment } from '@deepseek-ai/dsh-attachment';
+export { MAX_TIMER_DELAY_MS } from '@deepseek-ai/dsh-timeout';
+export { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess';
+export { credentialKey, type CredentialKey } from '@deepseek-ai/dsh-credentials';
 /**
  * Structural mirror of the host `CredentialProvider` record surface the OAuth
  * provider needs. Typed structurally because the store arrives via the
@@ -64,26 +34,12 @@ export interface CredentialRecordStore {
     readRecord(key: CredentialKey): Promise<unknown>;
     modifyRecord(key: CredentialKey, mutate: (current: unknown) => Promise<unknown>): Promise<unknown>;
 }
+export { isImageAdmissionError, type ImageMediaType, type SaveImageAttachment } from '@deepseek-ai/dsh-attachment';
 /**
- * Distinguish caller-correctable image admission failures from storage faults,
- * so an admission refusal projects text diagnostics while a storage fault is
- * reported as such.
- */
-export declare function isImageAdmissionError(error: unknown): boolean;
-/** Raster formats supported by the durable attachment vocabulary. */
-export type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
-/** One decoded image handed to the host attachment store. */
-export interface SaveImageAttachment {
-    data: Buffer;
-    mediaType: ImageMediaType;
-}
-/**
- * Structural mirror of the host `AttachmentStore.saveImages` surface. The
- * returned refs are opaque host values that ride inside `ContentBlock`
- * image blocks; typed `unknown` here and narrowed by the model content
- * contract at the projection site.
+ * Structural mirror of the host attachment store surface this plugin writes
+ * through. The service is resolved off the tool host at call time, so its
+ * concrete class is deliberately not imported.
  */
 export interface AttachmentStoreLike {
     saveImages(images: readonly SaveImageAttachment[]): Promise<readonly unknown[]>;
 }
-export {};