dsh-advisor-group 0.0.1

package/lib/index.d.mts

@@ -0,0 +1,252 @@
+import Schema from "@deepseek-ai/schemastery";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/config.d.ts
+type ProviderProtocol = 'openai' | 'anthropic' | 'gemini';
+type ProviderAuthMode = 'x-api-key' | 'bearer';
+interface AdvisorConfig {
+  id: string;
+  name: string;
+  avatar?: string;
+  provider: string;
+  model: string;
+  systemPrompt: string;
+  temperature?: number;
+  maxTokens?: number;
+  baseURL?: string;
+  apiKey?: string;
+  apiKeyEnv?: string;
+  protocol?: ProviderProtocol;
+  authMode?: ProviderAuthMode;
+  /**
+   * Per-advisor thinking mode; unset = provider default. `disabled` forces
+   * every request from this advisor to run without a thinking/reasoning block
+   * (mapped to `reasoningEffort: 'off'` on the DSH built-in channel; on the
+   * direct-http channel it maps to provider-specific "no thinking" params
+   * where supported). When `enabled`, the selected `reasoningEffort` applies.
+   */
+  thinking?: 'enabled' | 'disabled';
+  /**
+   * Per-advisor thinking strength; unset = provider/model default. Standard
+   * DSH effort ids (`off` disables thinking per request). On the direct-http
+   * channel the ids are mapped to provider-specific reasoning parameters
+   * (OpenAI `reasoning_effort`, Anthropic thinking budget, Gemini
+   * `thinkingConfig`).
+   */
+  reasoningEffort?: 'off' | 'low' | 'high' | 'max';
+  /**
+   * Per-advisor tool calling scope override; unset = the global default
+   * (`discussion.advisorTools`). Only meaningful on the direct-http channel.
+   */
+  tools?: 'readonly' | 'all' | 'off';
+  /**
+   * Server-side per-provider direct-key history for one advisor.
+   * Keys are never returned to the browser; they let a user switch back to a
+   * previously used provider without losing that provider's API key.
+   */
+  apiKeysByProvider?: Record<string, string>;
+  /**
+   * Client→server only: an explicit "clear the current provider's key" intent
+   * (SecretField semantics — an empty apiKey now means "keep the stored key").
+   * Stripped before persistence and never returned to the browser.
+   */
+  clearApiKey?: boolean;
+  /**
+   * Server→client only: per-provider key presence facts (no key material).
+   * Derived by `sanitizeConfig`; never persisted and never sent by the client.
+   */
+  apiKeyMetaByProvider?: Record<string, {
+    configured: boolean;
+    last4?: string;
+  }>;
+}
+interface DiscussionConfig {
+  maxRounds: number;
+  maxAdvisorsPerCall: number;
+  /**
+   * Deprecated (2026-09-05): rounds are now a sequential A → B → C relay,
+   * advisors are never invoked in parallel. Kept for stored-config
+   * compatibility only.
+   */
+  parallel: boolean;
+  /**
+   * Auto-deepen pipeline (2026-09-05): when true, the consultation runs up to
+   * `maxRounds` rounds automatically — after each round the driver model
+   * (the current agent's provider/model) asks a deeper follow-up, and a final
+   * synthesis closes the consultation.
+   */
+  autoDeepen: boolean;
+  /**
+   * Fallback driver model used when the session header cannot be read
+   * (e.g. resumed sessions without a request/header event).
+   */
+  driverModel?: {
+    provider: string;
+    model: string;
+  };
+  /**
+   * Deprecated (2026-09-05): the auto-deepen pipeline made this dormant.
+   * Kept in the schema only for stored-config compatibility;
+   * no longer rendered in the settings card.
+   */
+  stopOnConsensus: boolean;
+  /**
+   * Per-advisor call timeout in milliseconds (default 600000 = 10 min).
+   * Applied to both the ctx.llm and direct-http channels.
+   */
+  advisorTimeoutMs?: number;
+  /**
+   * Advisor tool calling scope (2026-09-05): 'readonly' (default) exposes only
+   * a read-only whitelist of the session's tools (read/grep/glob/web_search…);
+   * 'all' exposes every session-visible tool (incl. writable ones); 'off'
+   * disables tool calling. Only the direct-http OpenAI/Anthropic channel
+   * supports tool calling (ctx.llm / dsh-llm 0.1.2-rc.1 does not).
+   */
+  advisorTools?: 'readonly' | 'all' | 'off';
+  /**
+   * Driver (deep-question / conclusion) generation timeout in milliseconds
+   * (default 600000 = 10 min).
+   */
+  driverTimeoutMs?: number;
+}
+interface TriggerConfig {
+  requireClassifier: boolean;
+  allowWebFallback: boolean;
+  confidenceThreshold: number;
+}
+interface UiConfig {
+  theme: 'retro-green' | 'retro-amber' | 'retro-blue';
+  showTimestamps: boolean;
+  autoExpand: boolean;
+}
+interface QuotaConfig {
+  /** Enable the per-UTC-day new-consultation cap (cost safety valve). */
+  enabled: boolean;
+  /** Max new consultations per UTC day when enabled (1–100000), default 50. */
+  maxPerDay: number;
+}
+interface Config {
+  enabled: boolean;
+  discussion: DiscussionConfig;
+  trigger: TriggerConfig;
+  ui: UiConfig;
+  quota: QuotaConfig;
+  advisors: AdvisorConfig[];
+}
+declare const Config: Schema<Config>;
+//#endregion
+//#region src/types.d.ts
+interface DriverSource {
+  provider: string;
+  model: string;
+}
+type ChatRole = 'main' | 'advisor' | 'system';
+/** Why an advisor stream ended before producing a complete answer body. */
+interface TruncationInfo {
+  reason: 'timeout' | 'network';
+  atMs: number;
+}
+/** One tool step (agent-loop style) attached to the advisor message. */
+interface AdvisorToolStep {
+  kind: 'call' | 'result';
+  name: string;
+  text: string;
+  atMs: number;
+}
+interface ChatMessage {
+  role: ChatRole;
+  advisorId?: string;
+  advisorName?: string;
+  content: string;
+  thinking?: string;
+  /** Thinking split at each tool-call boundary, in stream order — the card
+   *  renders ONE row per segment (第 N 步思考), interleaved with tool rows. */
+  thinkingSegments?: string[];
+  /**
+   * The model's TEXT blocks spoken before each tool round (the DSH block order
+   * text → reasoning → tool-call): the "我要做什么" announcement the model
+   * makes to the user. Precise source for the card's 📋 行动·N rows.
+   */
+  actionDescriptions?: string[];
+  round?: number;
+  /** Tool-calling steps streamed as independent rows (not part of thinking). */
+  toolSteps?: AdvisorToolStep[];
+  /** Set when the stream was cut before a complete body (e.g. advisor timeout). */
+  truncated?: TruncationInfo;
+  ts: number;
+}
+interface ConsultSession {
+  id: string;
+  status: 'active' | 'completed' | 'cancelled';
+  question: string;
+  context?: string;
+  advisors: AdvisorConfig[];
+  maxRounds: number;
+  messages: ChatMessage[];
+  /** Working directory of the agent session (for cross-restart recovery). */
+  cwd?: string;
+  /** The agent's DSH session id: resume rebuilds THIS session so the card
+   *  (assembled from the agent session log) keeps receiving events. */
+  dshSessionId?: string;
+  /** Driver model source captured at first run; resume reuses it because the
+   *  rebuilt session has no request/header event to read the agent model from. */
+  driverSource?: DriverSource;
+  /** Why the consultation was interrupted: 'user-stop' (explicit stop button),
+   *  'exec-cancel' (host signal), 'abort-error' (unclassified AbortError),
+   *  or an advisor-level reason mirrored from truncated (timeout/network). */
+  stopReason?: string;
+  createdAt: number;
+  updatedAt: number;
+}
+interface AdvisorSummary {
+  advisorId: string;
+  advisorName: string;
+  corePoints: string[];
+  uncertainty?: string;
+}
+interface ConsultSummary {
+  sessionId: string;
+  question: string;
+  advisors: AdvisorSummary[];
+  consensus: string[];
+  disagreements: string[];
+  riskNotes: string[];
+  /** Driver-model synthesis appended after all auto-deepen rounds (2026-09-05). */
+  conclusion?: string;
+  /** True when the consultation was stopped by the user (partial content). */
+  stopped?: boolean;
+}
+//#endregion
+//#region src/events.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Events {
+    'advisor-group/session-start'(session: ConsultSession): void;
+    'advisor-group/message'(payload: {
+      sessionId: string;
+      message: ChatMessage;
+    }): void;
+    'advisor-group/delta'(payload: {
+      sessionId: string;
+      turn: number;
+      step: number;
+      advisorId: string;
+      advisorName?: string;
+      contentDelta?: string;
+      thinkingDelta?: string;
+      done?: boolean;
+    }): void;
+    'advisor-group/session-end'(payload: {
+      sessionId: string;
+      summary: ConsultSummary;
+    }): void;
+    'advisor-group/resume'(payload: {
+      sessionId: string;
+    }): void;
+  }
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "dsh-advisor-group";
+declare const inject: string[];
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Config, apply, inject, name };