dsh-agent-plugins-market 0.7.1 → 0.7.2

package/lib/types/contracts/market.d.ts

@@ -6,6 +6,7 @@ export declare const MARKET_ROUTES: {
     readonly overview: "/api/agent-plugins/overview";
     readonly mcpStatus: "/api/agent-plugins/mcp-status";
     readonly addMcpServer: "/api/agent-plugins/mcp-servers/add";
+    readonly importMcpServers: "/api/agent-plugins/mcp-servers/import";
     readonly lspStatus: "/api/agent-plugins/lsp-status";
     readonly lspServers: "/api/agent-plugins/lsp-servers";
     readonly addLspServer: "/api/agent-plugins/lsp-servers/add";
@@ -29,18 +30,81 @@ export declare const MARKET_ROUTES: {
     readonly mcpOverrides: "/api/agent-plugins/mcp-overrides";
     readonly setMcpOverride: "/api/agent-plugins/set-mcp-override";
     readonly setMcpServerEnabled: "/api/agent-plugins/set-mcp-server-enabled";
+    readonly setMcpServerTool: "/api/agent-plugins/set-mcp-server-tool";
     readonly mcpRetry: "/api/agent-plugins/mcp-retry";
     readonly mcpReauthorize: "/api/agent-plugins/mcp-reauthorize";
     readonly mcpBackend: "/api/agent-plugins/mcp-backend";
     readonly setMcpBackend: "/api/agent-plugins/set-mcp-backend";
     readonly userPanel: "/api/agent-plugins/user-panel";
 };
+/** One timeout's three layers: the user's value, the suite declaration, and the value in force. */
+export interface ServerTimeoutPolicy {
+    /** The user's stored value; null when the user inherits. */
+    user: number | null;
+    /** The suite's declared value; null when the suite declares none. */
+    suite: number | null;
+    /** The value in force. */
+    effective: number;
+    /** Which layer supplied `effective`. */
+    source: 'user' | 'suite' | 'default';
+}
+/** One tool list's layers: what the user stored and what the suite declares. */
+export interface ServerToolPolicy {
+    /** The user's stored list; null when the user set none. */
+    user: string[] | null;
+    /** The suite's declared list; null when the suite declares none. */
+    suite: string[] | null;
+    /** The list in force. */
+    effective: string[];
+}
+/** The OAuth opt-in's two layers. */
+export interface ServerAuthPolicy {
+    /** The user's stored value; null when the user set none. */
+    user: boolean | null;
+    /** The suite's declared value; null when the suite declares none. */
+    suite: boolean | null;
+    /** The value in force. */
+    effective: boolean;
+}
+/** The MCP per-server client policy as the service editor renders it. */
+export interface ServerPolicyPayload {
+    /** Per-tool-call timeout. */
+    toolCallTimeout: ServerTimeoutPolicy;
+    /** Startup timeout. */
+    startupTimeout: ServerTimeoutPolicy;
+    /** The tools the service denies. */
+    deniedTools: ServerToolPolicy;
+    /** The OAuth opt-in. */
+    auth: ServerAuthPolicy;
+}
 /** Editable service configuration; masked values are preserved when unchanged. */
 export interface ServerConfigPayload {
     kind: 'mcp' | 'lsp';
     id: string;
+    /** The declaration key this service carries, used to compose the document view. */
+    key: string;
     editable: boolean;
     config: Record<string, unknown>;
+    /** The stored policy and the suite declaration behind it; present for MCP services. */
+    policy?: ServerPolicyPayload;
+    /** The MCP mount backend; `host` cannot enforce startup timeouts or tool filters. */
+    backend?: 'builtin' | 'host';
+}
+/** The policy a service-config save sets (`number`/value) or clears back to inheritance (`null`). */
+export interface ServerPolicyRequest {
+    toolCallTimeoutMs?: number | null;
+    startupTimeoutMs?: number | null;
+    /** The user's deny list; null clears it. The suite's own entries stay in force. */
+    disabledTools?: string[] | null;
+    /** The user's OAuth opt-in; null clears it back to the suite's declaration. */
+    auth?: {
+        enabled: boolean;
+    } | null;
+}
+/** One rejected value as the API reports it: the field it belongs to and why. */
+export interface MarketFieldError {
+    field: string;
+    message: string;
 }
 /** Public model identities and exact-model reasoning options; never provider configuration. */
 export interface ModelCatalogPayload {
@@ -135,6 +199,9 @@ export type McpServerOverrideWire = {
     headers?: Record<string, string>;
     env?: Record<string, string>;
     args?: string[];
+    toolCallTimeoutMs?: number;
+    startupTimeoutMs?: number;
+    disabledTools?: string[];
 };
 /** Overrides for one suite keyed by mcp.json server key. */
 export type McpSuiteOverridesWire = Record<string, McpServerOverrideWire>;

package/lib/types/contracts/mcp-status.d.ts

@@ -3,6 +3,8 @@
 export interface McpStatusTool {
     name: string;
     description?: string;
+    /** The advertised input schema, kept only while it stays small enough to transport; absent otherwise. */
+    parameters?: unknown;
 }
 /** Whether an MCP row comes from a suite or direct host observation. */
 export type McpStatusKind = 'plugin' | 'direct';
@@ -39,6 +41,12 @@ export interface McpStatusEntry {
      *  runs the OAuth flow when the server answers 401, which the redacted
      *  configuration alone cannot show. */
     oauthDefault?: boolean;
+    /** Suite allow-list for this server's tools; absent when the suite narrows nothing. */
+    suiteEnabledTools?: string[];
+    /** Tools the suite's own declaration leaves out. */
+    suiteDisabledTools?: string[];
+    /** Tools the user turned off through the panel. */
+    userDisabledTools?: string[];
 }
 /** The MCP status response returned by the host. */
 export interface McpStatusPayload {
@@ -55,4 +63,7 @@ export interface McpStatusPayload {
         foreign: number;
     };
     directObservationOnly: boolean;
+    /** The mount backend the rows were observed under; `host` cannot enforce tool
+     *  filters or startup timeouts, so the panel disables those controls. */
+    backend?: 'builtin' | 'host';
 }

package/lib/types/model/layouts.d.ts

@@ -39,6 +39,19 @@ export declare const PLUGIN_LAYOUTS: readonly [{
 export type ManifestKind = (typeof PLUGIN_LAYOUTS)[number]['kind'];
 /** Kimi Code's primary spelling precedes its compatibility spelling within that dialect. */
 export declare const MANIFEST_ALIASES: Partial<Record<ManifestKind, readonly string[]>>;
+/**
+ * This client's Agent Plugins extension namespace (§8): manifest data rides
+ * `plugin.json` `extensions` under this key, and file-based extensions live
+ * in the top-level directory named exactly this. The namespace contract
+ * version is declared inside the manifest data.
+ */
+export declare const EXTENSION_NAMESPACE = "com.deepseek.harness";
+/** Namespace contract versions this manager implements. */
+export declare const NAMESPACE_SCHEMA_VERSIONS: ReadonlySet<string>;
+/** Namespace directory locations, relative to the plugin root. */
+export declare const NAMESPACE_DIR = "com.deepseek.harness";
+export declare const NAMESPACE_HOOKS_FILE: string;
+export declare const NAMESPACE_LSP_FILE: string;
 /** Equivalent plugin-owned path variables; these never resolve as credentials. */
 export declare const PLUGIN_ROOT_VARIABLES: ReadonlySet<string>;
 export declare const PLUGIN_DATA_VARIABLES: ReadonlySet<string>;
@@ -110,3 +123,10 @@ export declare const PROJECT_LAYOUTS: readonly [{
 }];
 /** Marketplace catalogs follow manifest layout order; the shared root catalog is the fallback. */
 export declare const MARKETPLACE_PATHS: readonly string[];
+/**
+ * Inline top-level manifest keys this manager reads for the portable v1
+ * dialect. The specification's closed manifest schema carries none of them
+ * (§5.2, §6.1), so under `agent-plugin-v1` they are reported as unknown
+ * top-level fields and ignored; every other dialect keeps reading them.
+ */
+export declare const V1_IGNORED_MANIFEST_KEYS: readonly string[];

package/lib/types/model/preset-source.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The source record this plugin presets.
+ *
+ * The first-party collection lives in its own repository. The plugin ships one
+ * registration pointing at it, so a fresh install lists the repository without
+ * anyone pasting a URL; from there it is an ordinary Git source — refresh to
+ * clone, then install and toggle its suites. Nothing marks it as different, and
+ * no setting owns it.
+ *
+ * @module model/preset-source
+ */
+import type { SourceRef } from './types.js';
+/** Source id the preset record registers under. */
+export declare const PRESET_SOURCE_ID = "dsh-agent-plugins";
+/** Repository the preset record points at. */
+export declare const PRESET_SOURCE_URL = "https://github.com/Sivan757/dsh-agent-plugins.git";
+/** The preset registration, as the market stores it. */
+export declare function presetSourceRef(): SourceRef;

package/lib/types/model/types.d.ts

@@ -67,6 +67,8 @@ export interface SuiteManifest {
     keywords?: string[];
     /** For agent-plugin-v1: the recognized `$schema` identifier. */
     schemaVersion?: string;
+    /** Parsed `com.deepseek.harness` extension data; present when the suite declares the namespace. */
+    harness?: HarnessNamespace;
 }
 /** Raw layout declarations are resolved once by the catalog into runtime resources. */
 export interface SuiteComponents {
@@ -110,6 +112,40 @@ export interface SuiteSurfaceCounts {
     agents: number;
     lsp: number;
 }
+/**
+ * Client-specific manifest data under the `com.deepseek.harness` extension
+ * namespace (Agent Plugins §8.1), carried by `plugin.json` `extensions`.
+ */
+export interface HarnessExtension {
+    /** Namespace contract version this suite was written against. */
+    schemaVersion: string;
+    /**
+     * Client policy for portable `mcp.json` servers, keyed by the server's own
+     * name in `mcp.json`; entries without a matching server are reported and
+     * ignored.
+     */
+    mcpServers?: Record<string, HarnessMcpPolicy>;
+}
+/**
+ * dsh-owned per-server policy for a portable MCP server: OAuth 2.1
+ * authorization for servers that answer `401` with a challenge, tool
+ * allow/deny lists, and timeout policies. These fields are outside the
+ * portable `mcp.json` schema by design (§7.2.1), so they ride the extension
+ * namespace instead of the package file.
+ */
+export interface HarnessMcpPolicy extends McpServerPolicy {
+    /** Opt in to OAuth 2.1 authorization (on by default; `enabled: false` opts out). */
+    auth?: {
+        enabled: boolean;
+        scope?: string;
+    };
+}
+/** Parsed namespace extension data of one suite, with server names pre-matched. */
+export interface HarnessNamespace {
+    schemaVersion: string;
+    /** Policy applied on top of the suite's portable MCP servers. */
+    mcpServers: Record<string, HarnessMcpPolicy>;
+}
 /** agent-plugins.org v1 `mcp.json` server variants. */
 export interface McpServerPolicy {
     enabledTools?: string[];
@@ -128,7 +164,7 @@ export interface McpServerStreamableHttp extends McpServerPolicy {
     type: 'streamable-http';
     url: string;
     headers?: Record<string, string>;
-    /** Opt in to OAuth 2.1 authorization for servers that answer `401` with a challenge (on by default; `enabled: false` opts out). */
+    /** OAuth 2.1 authorization; portable files take it from the namespace policy, dialect-native files declare it inline. */
     auth?: {
         enabled: boolean;
         scope?: string;

package/lib/types/runtime/agent-role-router.d.ts

@@ -1,7 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type SubagentCatalogEntry } from './subagent-catalog.js';
-import { type HostTranslate } from './host-locale.js';
-export declare const AGENT_ROLE_TOOL_NAME = "subagent_run";
+export declare const AGENT_ROLE_TOOL_NAME = "subagent_role";
 /** Panel identity is preserved so identically named cards from different suites remain addressable. */
 export interface AgentRoleEntry {
     name: string;
@@ -45,6 +44,10 @@ export interface AgentRoleDelegation {
     persona: string;
     agentOptions?: AgentRoleOptions;
 }
+/** A one-shot foreground run carries its own cancellation signal on the request. */
+export interface AgentRoleRunRequest extends AgentRoleDelegation {
+    signal: AbortSignal;
+}
 export interface AgentRoleHost {
     tools: {
         register(definition: unknown): () => void;
@@ -66,18 +69,59 @@ export interface AgentRoleHost {
             childId: string;
             messageId: string;
         }>;
+        /** One-shot foreground run: the host settles it and hands back the child's output. */
+        start(provider: string, request: AgentRoleRunRequest): Promise<AgentRoleRun>;
     };
 }
+/**
+ * JSON value crossing the tool-result boundary. Declared locally so this plugin
+ * keeps its declared host surface: the registry performs the authoritative
+ * lossless snapshot of the child's content blocks on the way out.
+ */
+export type AgentRoleJson = null | boolean | number | string | AgentRoleJson[] | {
+    [key: string]: AgentRoleJson;
+};
+/** One settled foreground role run; `result` resolves with the child's terminal output. */
+export interface AgentRoleRun {
+    id: string;
+    result: Promise<{
+        output: unknown[];
+        stopReason: string;
+        diagnostic?: string;
+    }>;
+    dispose(): Promise<void>;
+}
+/** One tracked background role job as the host `jobs` registry sees it. */
+export interface AgentRoleJob {
+    cancel(reason?: string): void;
+    done: Promise<{
+        status: string;
+        detail?: string;
+    }>;
+}
+/** The host `jobs` registry seam, reached through `ctx.get('jobs')`. */
+export interface AgentRoleJobs {
+    start(spec: {
+        kind: string;
+        label: string;
+        owner?: unknown;
+        run(): AgentRoleJob;
+    }): string;
+}
 /** Strict YAML parsing prevents malformed routing metadata from silently inheriting wider privileges. */
 export declare function parseAgentRole(text: string): AgentRolePolicy;
 /**
- * Resolve the child LLM options one card may contribute.
+ * Resolve the child LLM options for one role call.
  *
- * A card route is advisory. Only an exact `provider` plus `model` pair is
- * applied, and only when the live LLM runtime accepts it; every other
- * declaration — a bare id, a Claude alias, a lone `provider`, an unsupported
- * effort — degrades to inheriting the parent route and reports a diagnostic.
- * @param policy - the card's parsed routing metadata.
+ * The call's own `provider` + `model` pair wins, and the role card supplies the
+ * default when the call names neither. Only an exact pair is applied, and only
+ * when the live LLM runtime accepts it; a bare id, a Claude alias, a lone
+ * `provider` or an unsupported effort degrades to inheriting the parent route
+ * and reports a diagnostic. An explicit route with no explicit effort uses the
+ * selected model's default, so a card's effort never leaks onto a route it was
+ * not written for.
+ * @param policy - the card's parsed routing metadata, used as the default route.
+ * @param requested - the route the call itself asked for.
  * @param parent - the calling Agent whose route an unusable declaration falls back to.
  * @param llm - live LLM runtime owning provider, model and effort validation.
  * @param signal - tool-call cancellation signal.
@@ -85,18 +129,48 @@ export declare function parseAgentRole(text: string): AgentRolePolicy;
  * @param diagnose - diagnostic sink; degradation is reported, never silent.
  * @returns the options to send, or undefined for pure inheritance.
  */
-export declare function resolveAgentOptions(policy: AgentRolePolicy, parent: unknown, llm: AgentRoleHost['llm'], signal: AbortSignal, subject: string, diagnose: (message: string) => void): Promise<AgentRoleOptions | undefined>;
+export declare function resolveAgentOptions(policy: AgentRolePolicy, requested: AgentRoleOptions, parent: unknown, llm: AgentRoleHost['llm'], signal: AbortSignal, subject: string, diagnose: (message: string) => void): Promise<AgentRoleOptions | undefined>;
 /** Stable summaries; invalid declarations are excluded and transient read failures abort publication. */
 export declare function agentRoleCatalog(entries: AgentRoleEntry[], signal: AbortSignal, diagnose?: (message: string) => void, projectDir?: string): Promise<SubagentCatalogEntry[]>;
 /** Read the same declaration for catalog summaries and execution, including inline resources. */
 export declare function readAgentRole(entry: AgentRoleEntry, projectDir?: string): Promise<AgentRolePolicy>;
 /**
- * Start one role child and return its durable id without waiting for the result.
- * Resume state, steering, and the settlement notice belong to the host's
- * continuation manager; this executor owns only role resolution.
+ * How one role call reaches a child, mirroring the host's own delegation tool.
+ *
+ * `continuable` is the default: the host establishes a durable child and this
+ * returns its id immediately, leaving resume state, steering and the settlement
+ * notice to the continuation manager. `foreground` starts a one-shot run and
+ * returns its report as this call's result, for a caller that needs the answer
+ * before its next action. `background` starts the same one-shot run as a tracked
+ * job, so the caller collects it later with `job_output` and can stop it with
+ * `job_kill` instead of holding the turn open.
  */
-export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, agentName: string, prompt: string, parent: unknown, signal: AbortSignal, diagnose?: (message: string) => void): Promise<{
+export type AgentRoleRunMode = 'continuable' | 'background' | 'foreground';
+/** One role call's outcome, discriminated so the tool can render each channel. */
+export type AgentRoleResult = {
+    kind: 'continuable';
     subagentId: string;
-}>;
-/** Mount once after tools, llm and subagents are available; the returned disposer belongs to the plugin lifecycle. */
-export declare function mountAgentRoleTool(ctx: Context, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, t?: HostTranslate): () => void;
+} | {
+    kind: 'background';
+    jobId: string;
+} | {
+    kind: 'foreground';
+    runId: string;
+    output: AgentRoleJson[];
+};
+/**
+ * Run one role child through the requested channel.
+ * @param host - the exact live seams this executor owns: tools, llm and subagents.
+ * @param mode - which channel the call asked for.
+ * @param jobs - the host jobs registry; only the `background` channel needs it.
+ */
+export declare function executeAgentRole(host: AgentRoleHost, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>, agentName: string, prompt: string, parent: unknown, requestedRoute: AgentRoleOptions, mode: AgentRoleRunMode, signal: AbortSignal, diagnose?: (message: string) => void, jobs?: AgentRoleJobs): Promise<AgentRoleResult>;
+/**
+ * Mount once after tools, llm and subagents are available; the returned disposer belongs to the plugin lifecycle.
+ *
+ * The delegation contract lives here rather than in the injected catalog: a tool
+ * description is present in every request, while the catalog message is
+ * re-published whenever roles change, so guidance kept out of the catalog is
+ * sent once and stays readable through compaction.
+ */
+export declare function mountAgentRoleTool(ctx: Context, listRoles: (parent?: unknown) => Promise<AgentRoleEntry[]>): () => void;

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

@@ -1,5 +1,5 @@
 /** Host runtime dictionary keys (mirrored for zh and en). */
-export type HostLocaleKey = 'subagentCatalogIntro' | 'subagentCatalogUpdated' | 'subagentCatalogEmpty' | 'subagentCatalogCall' | 'commandAcknowledged' | 'userCommandSourceLabel' | 'feedbackToolCardTitle';
+export type HostLocaleKey = 'commandAcknowledged' | 'userCommandSourceLabel' | 'feedbackToolCardTitle';
 export type HostTranslate = (key: HostLocaleKey, params?: Record<string, string>) => string;
 interface ResolvedLocale {
     t: HostTranslate;

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

@@ -63,6 +63,8 @@ export declare class LoopbackOAuthClientProvider implements OAuthClientProvider
     private providerState;
     /** The transport generation whose `finishAuth` completes the browser leg. */
     private activeTransport;
+    /** One process-local OAuth state value for the current browser leg. */
+    private expectedState;
     /** Resolves `true` when the leg saved tokens, `false` when it failed; undefined while no leg is open. */
     private browserLegSettled;
     private callbackServer;
@@ -73,6 +75,8 @@ export declare class LoopbackOAuthClientProvider implements OAuthClientProvider
     constructor(serverName: string, storage: OAuthStorageConfig, scope: string | undefined, log: (message: string) => void, store: unknown, opener?: BrowserOpener);
     get redirectUrl(): string;
     get clientMetadata(): OAuthClientMetadata;
+    /** Issue one unpredictable state value for the SDK's authorization request. */
+    state(): string;
     clientInformation(): Promise<OAuthClientInformationMixed | undefined>;
     saveClientInformation(clientInformation: OAuthClientInformationMixed): Promise<void>;
     tokens(): Promise<OAuthTokens | undefined>;

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

@@ -1,6 +1,6 @@
 import type { Config } from './mcp-client/config.js';
 import { type McpServerOverride, type McpSuiteOverrides } from './mcp-overrides.js';
-import type { McpServer, McpServerSse, McpServerStdio, McpServerStreamableHttp, Suite } from '../model/types.js';
+import type { HarnessMcpPolicy, McpServer, McpServerPolicy, McpServerSse, McpServerStdio, McpServerStreamableHttp, Suite } from '../model/types.js';
 export interface McpMountRequest {
     suiteId: string;
     serverKey: string;
@@ -16,6 +16,32 @@ export interface EffectiveMcpServer {
     enabled: boolean;
     /** External credential references the effective definition needs. */
     credentialRefs: string[];
+    /** The suite declaration and the user's override as they resolved. */
+    policy: ResolvedMcpPolicy;
+}
+/** One timeout as three layers: what the user set, what the suite declared, and the value in force. */
+export interface McpTimeoutResolution {
+    /** The user's stored value; null when the user inherits. */
+    user: number | null;
+    /** The suite's declared value; null when the suite declares none. */
+    suite: number | null;
+    /** The value in force. */
+    effective: number;
+    /** Which layer supplied `effective`. */
+    source: 'user' | 'suite' | 'default';
+}
+/** One server's client policy after the suite declaration and the user's override meet. */
+export interface ResolvedMcpPolicy {
+    /** Suite allow-list; the user cannot widen it. */
+    enabledTools?: string[];
+    /** The suite's own deny list. */
+    suiteDisabledTools?: string[];
+    /** Effective deny list: the suite's own entries unioned with the user's. */
+    disabledTools?: string[];
+    /** Per-tool-call timeout. */
+    toolCallTimeout: McpTimeoutResolution;
+    /** Startup timeout. */
+    startupTimeout: McpTimeoutResolution;
 }
 export type McpMountFailureCode = 'unsupported-transport' | 'missing-credential' | 'credential-error' | 'unmount-failed' | 'mount-failed'
 /** The derived serverName's namespace is already mounted by another MCP client — informational, not a failure. */
@@ -36,18 +62,10 @@ export interface McpCredentialResolver {
     } | undefined>;
 }
 /**
- * The effective view of one suite's `mcp.json` servers: the user's per-server
- * overrides applied, every row flagged with whether it is used at all, and each
- * row's credential references read off the effective shape. Mounting, status
- * and detail rendering read this one projection, so a server cannot be listed
- * as enabled while mounting something else.
- */
-export declare function effectiveMcpServers(suite: Suite, overrides?: McpSuiteOverrides): EffectiveMcpServer[];
-/**
- * Build one mount request per supported mcp.json server, resolving every
- * `${NAME}` through the credential resolver before a child process or HTTP
- * request is created. Missing references fail closed per server instead of
- * becoming empty strings.
+ * Build one mount request per supported mcp.json server, expanding built-in
+ * variables (and, for user-owned data, `${NAME}` credential references)
+ * before a child process or HTTP request is created. Missing references fail
+ * closed per server instead of becoming empty strings.
  *
  * @param overrides user-owned per-server overrides (url/headers/env/args
  *   replacement plus enable/disable); applied before mount. Disabled servers
@@ -61,6 +79,50 @@ export declare function toMcpMounts(suite: Suite, pluginDataRoot: string, overri
     failures: McpMountFailure[];
     credentialRefs: string[];
 }>;
+/**
+ * Whether a suite's MCP declarations are package data under the portable
+ * format. Installed v1 suites are; the user's own `~/.agents/mcp.json`,
+ * project-native config, and every dialect-native file are user-owned data
+ * where `${NAME}` credential references stay resolvable.
+ */
+export declare function isPortableMcp(suite: Suite): boolean;
+/**
+ * The `com.deepseek.harness` policy declared for one portable server.
+ * Server keys in the namespace match the server's own name in `mcp.json`;
+ * `serverKey` is that name at discovery time.
+ */
+export declare function namespaceMcpPolicy(suite: Suite, serverKey: string): HarnessMcpPolicy | undefined;
+/**
+ * The effective view of one suite's `mcp.json` servers: the user's per-server
+ * overrides applied, every row flagged with whether it is used at all, and each
+ * row's credential references read off the effective shape. Mounting, status
+ * and detail rendering read this one projection, so a server cannot be listed
+ * as enabled while mounting something else.
+ *
+ * Portable v1 suites (`isPortableMcp`) carry package data: their credential
+ * reference list is empty by definition (§9.2 leaves unrecognized
+ * placeholder-like text literal), and client policy comes from the
+ * `com.deepseek.harness` namespace instead. Overrides applied by the user are
+ * user-owned data, so a reference a user typed into an override still
+ * resolves.
+ */
+export declare function effectiveMcpServers(suite: Suite, overrides?: McpSuiteOverrides): EffectiveMcpServer[];
+/**
+ * The suite's declared per-server policy. The `com.deepseek.harness`
+ * namespace seat carries the policy a portable `mcp.json` has no room for and
+ * wins over an inline declaration; dialect-native files declare it inline.
+ */
+export declare function declaredMcpPolicy(server: McpServerPolicy, policy: HarnessMcpPolicy | undefined): McpServerPolicy;
+/**
+ * Bring the suite's declaration and the user's override together.
+ *
+ * A timeout is a plain override: the user's value wins, a declaration fills in
+ * when the user set none, and the built-in default stands behind both. Tool
+ * filtering only tightens: the effective deny list is the suite's entries
+ * unioned with the user's, and the suite's allow-list stands as declared, so a
+ * user cannot open a tool the suite left out.
+ */
+export declare function resolveMcpPolicy(declared: McpServerPolicy, override: McpServerOverride | undefined): ResolvedMcpPolicy;
 /** Find external credential references used by one MCP server definition. */
 export declare function credentialRefsInServer(server: McpServer): string[];
 /**

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

@@ -19,3 +19,25 @@ export declare function loadUserMcpSuite(agentsRoot: string): Promise<Suite & {
 export declare function addUserMcpServer(agentsRoot: string, name: string, server: unknown): Promise<void>;
 /** The user's hand-written MCP declaration file: `<agentsRoot>/mcp.json`. */
 export declare function userMcpPath(agentsRoot: string): string;
+/** One pasted entry: the key it lands under and the server definition it carries. */
+export interface McpImportEntry {
+    name: string;
+    server: unknown;
+}
+/** What one pasted import wrote, and what it left out with a reason each. */
+export interface McpImportResult {
+    imported: string[];
+    skipped: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+/**
+ * Import several pasted servers in one write.
+ *
+ * Every entry is judged on its own so one bad definition cannot take the rest
+ * of the paste with it, and an existing name is kept unless the caller asked to
+ * overwrite. The file is written once, after every entry has been checked, so a
+ * rejected entry never lands half-written beside the accepted ones.
+ */
+export declare function importUserMcpServers(agentsRoot: string, entries: readonly McpImportEntry[], overwrite?: boolean): Promise<McpImportResult>;

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

@@ -1,6 +1,8 @@
 import type { McpServerSse, McpServerStreamableHttp, McpServerStdio } from '../model/types.js';
 /** HTTP-shaped server sources (url + headers carriers) overrides can edit. */
 type McpServerHttp = McpServerStreamableHttp | McpServerSse;
+/** The largest timeout a bridge config and the host timer can hold. */
+export declare const MAX_TIMEOUT_MS = 2147483647;
 /** Per-server override record; absent fields pass through from the source. */
 export type McpServerOverride = {
     /** Validated complete user configuration, retaining source-owned identity. */
@@ -20,7 +22,18 @@ export type McpServerOverride = {
         enabled: boolean;
         scope?: string;
     };
+    /** Per-tool-call timeout in milliseconds; absent inherits the suite's value or the bridge default. */
+    toolCallTimeoutMs?: number;
+    /** Startup timeout in milliseconds; absent inherits the suite's value or the bridge default. */
+    startupTimeoutMs?: number;
+    /** Tool names the user turned off; the suite's own deny list stays in force beside them. */
+    disabledTools?: string[];
 };
+/** Timeout fields a policy save can set (`number`) or clear back to inheritance (`null`). */
+export interface McpTimeoutPatch {
+    toolCallTimeoutMs?: number | null;
+    startupTimeoutMs?: number | null;
+}
 /** Overrides for one suite, keyed by mcp.json server key. */
 export type McpSuiteOverrides = Record<string, McpServerOverride>;
 /** The overrides directory under the plugin data root. */
@@ -35,6 +48,31 @@ export declare function saveSuiteOverrides(dataRoot: string, suiteId: string, ov
 export declare function sanitizeOverrides(raw: unknown): McpSuiteOverrides;
 /** Validate a client-supplied patch for one server into an override value. */
 export declare function sanitizeOverridePatch(patch: unknown): McpServerOverride | undefined;
+/**
+ * Validate one policy save as it arrives over the wire. An absent field leaves
+ * its stored value alone, `null` clears one back to inheritance, and a positive
+ * whole number of milliseconds within the timer range sets it; anything else
+ * rejects the save with a readable reason.
+ */
+export declare function parseTimeoutPatch(raw: unknown): McpTimeoutPatch;
+/** The client policy a service-config save may carry alongside the definition. */
+export interface McpPolicyPatch {
+    toolCallTimeoutMs?: number | null;
+    startupTimeoutMs?: number | null;
+    /** The user's deny list; null clears it, an absent field keeps it. */
+    disabledTools?: string[] | null;
+    /** The user's OAuth opt-in; null clears it, an absent field keeps it. */
+    auth?: {
+        enabled: boolean;
+        scope?: string;
+    } | null;
+}
+/**
+ * Validate a client-supplied policy patch. An absent field keeps its stored
+ * value, `null` clears it back to the suite's declaration or the default, and
+ * any other shape is rejected with the reason it failed.
+ */
+export declare function parseMcpPolicyPatch(raw: unknown): McpPolicyPatch;
 /**
  * Merge one client patch into the override already on disk.
  *
@@ -55,4 +93,10 @@ export declare function mergeOverridePatch(existing: McpServerOverride, patch: M
  * persisting them here.
  */
 export declare function applyOverride(server: McpServerStdio | McpServerHttp, override: McpServerOverride | undefined): McpServerStdio | McpServerHttp;
+/**
+ * One server with its client policy fields removed: the shape the portable
+ * `mcp.json` schema accepts. The service editor renders and saves this shape,
+ * so a timeout never reaches a document that has no seat for it.
+ */
+export declare function withoutPolicyFields<T extends McpServerStdio | McpServerHttp>(server: T): T;
 export {};

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

@@ -5,3 +5,9 @@ export declare function redactMcpOverrides(value: Record<string, Record<string,
 export declare function isSensitiveKey(key: string): boolean;
 /** Redact credential-bearing query values from an endpoint URL. */
 export declare function redactUrl(raw: string): string;
+/**
+ * Redact every URL embedded in an error message before the message reaches a
+ * log line or a diagnostic: connection failures echo the server's endpoint,
+ * and endpoints carry credential-bearing queries.
+ */
+export declare function redactErrorMessage(raw: string): string;