@moxxy/sdk 0.8.0 → 0.9.0

package/src/mode-helpers.ts

@@ -383,6 +383,15 @@ export async function collectProviderStream(
      * strategy then falls back to its tools/system/tail breakpoints only.
      */
     stablePrefixIndex?: number;
+    /**
+     * Number of trailing messages in `messages` that are volatile — injected
+     * for this call only (e.g. goal mode's `trailingUserText` nudge) and
+     * absent from the append-only log, so they won't recur at the same
+     * position next call. Forwarded to the cache strategy as
+     * `volatileTailMessageCount` so it keeps its rolling tail breakpoint
+     * before them instead of paying a guaranteed-wasted cache write.
+     */
+    volatileTailCount?: number;
   } = {},
 ): Promise<StreamResult> {
   // Lazy tool gating (opt-in): send only always-on + loaded tool schemas, and
@@ -410,12 +419,20 @@ export async function collectProviderStream(
         ...(opts.stablePrefixIndex != null && opts.stablePrefixIndex >= 0
           ? { stablePrefixMessageIndex: opts.stablePrefixIndex }
           : {}),
+        ...(opts.volatileTailCount != null && opts.volatileTailCount > 0
+          ? { volatileTailMessageCount: opts.volatileTailCount }
+          : {}),
       })
     : undefined;
 
+  // NOTE: `system` is deliberately NOT prefilled with ctx.systemPrompt — the
+  // composed system prompt already rides as the leading system-role message
+  // (see projectMessages), and providers deliver `req.system` IN ADDITION to
+  // message-derived system text. Prefilling it would duplicate the prompt.
+  // It stays as the side channel `onBeforeProviderCall` hooks use to inject
+  // per-request system text (e.g. the memory consolidation nudge).
   const req = {
     model: ctx.model,
-    system: ctx.systemPrompt,
     messages: effectiveMessages,
     ...(toolList ? { tools: toolList } : {}),
     ...(cacheHints && cacheHints.length > 0 ? { cacheHints } : {}),

package/src/provider.ts

@@ -38,6 +38,16 @@ export interface CacheHint {
 
 export interface ProviderRequest {
   readonly model: string;
+  /**
+   * Extra system text delivered IN ADDITION to any `role: 'system'`
+   * messages in `messages`. The loop helpers project the composed system
+   * prompt as the leading system message (so cache hints can target it)
+   * and leave this unset; `onBeforeProviderCall` hooks use it as the
+   * side channel for per-request system injections (e.g. plugin-memory's
+   * consolidation nudge), and direct callers (e.g. skill synthesis) may
+   * set it instead of crafting a system message. Providers MUST deliver
+   * it — appended after the message-derived system text — never drop it.
+   */
   readonly system?: string;
   readonly messages: ReadonlyArray<ProviderMessage>;
   readonly tools?: ReadonlyArray<ToolDef>;

package/src/session-like.ts

@@ -165,16 +165,45 @@ export interface WorkflowRunView {
   readonly steps: ReadonlyArray<{ readonly id: string; readonly status: string; readonly error?: string }>;
 }
 
+/** Validation result for a draft YAML — backs the visual builder (phase 2). */
+export interface WorkflowValidateView {
+  readonly ok: boolean;
+  /** One readable line per issue; empty when `ok`. */
+  readonly errors: ReadonlyArray<string>;
+}
+
+/** Result of persisting a workflow from the builder. */
+export interface WorkflowSaveView {
+  readonly name: string;
+  readonly scope: string;
+  readonly path: string;
+}
+
 /**
  * The slice of the workflows API a channel needs to drive the `/workflows`
  * modal (list, enable/disable toggle, run). Present on a local Session when
  * `@moxxy/plugin-workflows` is wired; a `RemoteSession` leaves
  * {@link SessionLike.workflows} undefined and the UI degrades gracefully.
+ *
+ * `validateDraft` / `save` / `getRun` back the upcoming visual workflow
+ * builder (phase 2); they are optional so older hosts and remote sessions
+ * stay capability-detectable — a channel must feature-check before calling.
  */
 export interface WorkflowsView {
   list(): Promise<ReadonlyArray<WorkflowSummaryView>>;
   setEnabled(name: string, enabled: boolean): Promise<void>;
   run(name: string): Promise<WorkflowRunView>;
+  /** Parse + validate a draft YAML without saving it. */
+  validateDraft?(yaml: string): Promise<WorkflowValidateView>;
+  /**
+   * Persist a workflow from full YAML (create or overwrite). `previousName`
+   * (the name the builder loaded) supports rename: when it differs from the
+   * YAML's name, the old file + registry entry are removed so a rename doesn't
+   * leave an orphaned duplicate.
+   */
+  save?(yaml: string, previousName?: string): Promise<WorkflowSaveView>;
+  /** Fetch one saved workflow's canonical YAML + on-disk metadata. */
+  getRun?(name: string): Promise<{ readonly name: string; readonly scope: string; readonly path: string; readonly yaml: string } | null>;
 }
 
 /** One installable plugin in {@link PluginsAdminView.catalog}. */

package/src/subagent.ts

@@ -26,6 +26,18 @@ export interface SubagentSpec {
   readonly allowedTools?: ReadonlyArray<string>;
   /** Human-readable label surfaced in `subagent_*` event payloads. */
   readonly label?: string;
+  /**
+   * When true, the child session stays alive after the first turn for
+   * {@link SubagentSpawner.continue}. `subagent_completed` is deferred until
+   * continue or release. Used by the workflow `awaitInput` pause/resume flow.
+   */
+  readonly retainSession?: boolean;
+}
+
+export interface SubagentContinueArgs {
+  readonly childSessionId: SessionId;
+  readonly prompt: string;
+  readonly label?: string;
 }
 
 export interface SubagentResult {
@@ -43,4 +55,8 @@ export interface SubagentSpawner {
   spawn(spec: SubagentSpec): Promise<SubagentResult>;
   /** Run N children in parallel; resolves with results in input order. */
   spawnAll(specs: ReadonlyArray<SubagentSpec>): Promise<ReadonlyArray<SubagentResult>>;
+  /** Append a user turn and run a retained child again (requires `retainSession`). */
+  continue?(args: SubagentContinueArgs): Promise<SubagentResult>;
+  /** Drop a retained session without completing it. */
+  release?(childSessionId: SessionId): void;
 }

package/src/tunnel.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import { isCliTunnelAvailable, spawnCliTunnel } from './tunnel.js';
+
+const URL_RE = /https:\/\/[a-z0-9-]+\.example\.test/i;
+
+describe('spawnCliTunnel', () => {
+  it('resolves the parsed URL + pid when the child prints a matching line', async () => {
+    const handle = await spawnCliTunnel({
+      cmd: process.execPath,
+      // Print a noise line, then the URL, then stay alive so close() can kill it.
+      args: ['-e', 'console.log("starting up"); console.log("url=https://abc-123.example.test ready"); setInterval(()=>{}, 1000);'],
+      urlRegex: URL_RE,
+      name: 'faketunnel',
+      timeoutMs: 5_000,
+    });
+    expect(handle.url).toBe('https://abc-123.example.test');
+    expect(handle.pid).toBeGreaterThan(0);
+    await handle.close();
+  });
+
+  it('parses URLs printed on stderr too', async () => {
+    const handle = await spawnCliTunnel({
+      cmd: process.execPath,
+      args: ['-e', 'console.error("https://err-host.example.test"); setInterval(()=>{}, 1000);'],
+      urlRegex: URL_RE,
+      timeoutMs: 5_000,
+    });
+    expect(handle.url).toBe('https://err-host.example.test');
+    await handle.close();
+  });
+
+  it('rejects when the child exits before emitting a URL', async () => {
+    await expect(
+      spawnCliTunnel({
+        cmd: process.execPath,
+        args: ['-e', 'process.exit(3)'],
+        urlRegex: URL_RE,
+        name: 'faketunnel',
+        timeoutMs: 5_000,
+      }),
+    ).rejects.toThrow(/faketunnel exited \(code 3\) before emitting a URL/);
+  });
+
+  it('rejects when the executable cannot be spawned', async () => {
+    await expect(
+      spawnCliTunnel({
+        cmd: 'definitely-not-a-real-binary-xyz',
+        args: [],
+        urlRegex: URL_RE,
+        name: 'nope',
+        timeoutMs: 2_000,
+      }),
+    ).rejects.toThrow();
+  });
+
+  it('rejects on timeout when no URL is ever printed (and kills the child)', async () => {
+    await expect(
+      spawnCliTunnel({
+        cmd: process.execPath,
+        args: ['-e', 'setInterval(()=>{}, 1000);'],
+        urlRegex: URL_RE,
+        name: 'slowtunnel',
+        timeoutMs: 150,
+      }),
+    ).rejects.toThrow(/slowtunnel: timed out after 150ms/);
+  });
+});
+
+describe('isCliTunnelAvailable', () => {
+  it('resolves true for an installed runnable binary', async () => {
+    // node is always present in the test runtime and supports --version.
+    expect(await isCliTunnelAvailable(process.execPath)).toBe(true);
+  });
+
+  it('resolves false for a missing binary', async () => {
+    expect(await isCliTunnelAvailable('definitely-not-a-real-binary-xyz')).toBe(false);
+  });
+});

package/src/tunnel.ts

@@ -5,6 +5,8 @@
  * plugins, like every other block); core seeds a `localhost` no-op provider so
  * `getActive()` is non-null.
  */
+import { spawn, type ChildProcess } from 'node:child_process';
+
 export interface TunnelOpenOptions {
   readonly port: number;
   readonly host: string;
@@ -24,3 +26,173 @@ export interface TunnelProviderDef {
   /** Optional readiness gate (e.g. the `cloudflared` binary is installed). */
   isAvailable?(): Promise<boolean>;
 }
+
+// ---------------------------------------------------------------------------
+// Shared CLI-tunnel subprocess management
+//
+// cloudflared/ngrok (channel-web) and the webhooks tunnel all do the same
+// thing: spawn a CLI, watch its stdout/stderr for the assigned public URL,
+// resolve once it's seen (or reject on timeout/exit/error), and guarantee the
+// child is killed on close *and* on process exit (Node does not reap children).
+// `spawnCliTunnel` is the single implementation they all share.
+// ---------------------------------------------------------------------------
+
+/**
+ * Guarantees spawned tunnel children (cloudflared/ngrok/…) never orphan or
+ * leak. Node does NOT kill child processes when the parent exits, so we track
+ * every live child and kill any survivors on process teardown — in addition to
+ * the explicit `close()` path. Each tracked child is also force-killed
+ * (SIGKILL) if it ignores SIGTERM, so a wedged tunnel can't drain
+ * memory/handles.
+ */
+const liveChildren = new Set<ChildProcess>();
+let exitHookInstalled = false;
+
+function killChild(child: ChildProcess): void {
+  if (child.exitCode != null || child.signalCode != null) return;
+  try {
+    child.kill('SIGTERM');
+  } catch {
+    /* already gone */
+  }
+  // Escalate if it doesn't exit promptly. unref so this timer never holds the
+  // event loop open on its own.
+  const t = setTimeout(() => {
+    try {
+      child.kill('SIGKILL');
+    } catch {
+      /* gone */
+    }
+  }, 2000);
+  t.unref?.();
+  child.once('exit', () => clearTimeout(t));
+}
+
+function ensureExitHook(): void {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  const killAll = (): void => {
+    for (const child of liveChildren) {
+      try {
+        child.kill('SIGKILL'); // process is exiting; be decisive, no async escalation
+      } catch {
+        /* gone */
+      }
+    }
+    liveChildren.clear();
+  };
+  process.once('exit', killAll);
+  process.once('SIGINT', killAll);
+  process.once('SIGTERM', killAll);
+}
+
+/** Track a spawned child; returns an `untrack()` that also kills it cleanly. */
+function trackChild(child: ChildProcess): () => Promise<void> {
+  ensureExitHook();
+  liveChildren.add(child);
+  child.once('exit', () => liveChildren.delete(child));
+  return () =>
+    new Promise<void>((resolve) => {
+      liveChildren.delete(child);
+      if (child.exitCode != null || child.signalCode != null) return resolve();
+      child.once('exit', () => resolve());
+      killChild(child);
+    });
+}
+
+export interface SpawnCliTunnelOptions {
+  /** Executable to spawn (e.g. `cloudflared`, `ngrok`). */
+  readonly cmd: string;
+  /** Arguments passed to the executable. */
+  readonly args: ReadonlyArray<string>;
+  /** Matches the assigned public URL in a chunk of the CLI's stdout/stderr. */
+  readonly urlRegex: RegExp;
+  /** How long to wait for the URL before giving up. Default 30s. */
+  readonly timeoutMs?: number;
+  /** Human-readable name used in error messages. Defaults to `cmd`. */
+  readonly name?: string;
+}
+
+/** A spawned CLI tunnel: the public-URL handle plus the child's pid. */
+export interface CliTunnelHandle extends TunnelHandle {
+  /** Spawned process id (-1 if the platform didn't assign one). */
+  readonly pid: number;
+}
+
+const DEFAULT_TUNNEL_URL_TIMEOUT_MS = 30_000;
+
+/**
+ * Spawn a CLI tunnel, parse the assigned public URL out of its output, and
+ * resolve a {@link CliTunnelHandle}. The child is tracked so it is killed on
+ * `close()`, on tunnel-switch, and on process exit (no orphans). Rejects on
+ * timeout, spawn error, or premature exit (the child is killed in every reject
+ * path). This is the single spawn-and-parse implementation behind the
+ * cloudflared/ngrok tunnel providers and the webhooks tunnel.
+ */
+export function spawnCliTunnel(opts: SpawnCliTunnelOptions): Promise<CliTunnelHandle> {
+  const { cmd, args, urlRegex } = opts;
+  const name = opts.name ?? cmd;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TUNNEL_URL_TIMEOUT_MS;
+
+  return new Promise<CliTunnelHandle>((resolve, reject) => {
+    let child: ChildProcess;
+    try {
+      child = spawn(cmd, args as string[], { stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (err) {
+      reject(
+        new Error(
+          `failed to spawn ${name} — is it installed? (${err instanceof Error ? err.message : String(err)})`,
+        ),
+      );
+      return;
+    }
+
+    const untrack = trackChild(child);
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      void untrack();
+      reject(new Error(`${name}: timed out after ${timeoutMs}ms waiting for the tunnel URL`));
+    }, timeoutMs);
+    timer.unref?.();
+
+    const onData = (buf: Buffer): void => {
+      if (settled) return; // drain quietly once resolved so the pipe never fills
+      const url = urlRegex.exec(buf.toString('utf8'))?.[0] ?? null;
+      if (!url) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ url, pid: child.pid ?? -1, close: untrack });
+    };
+
+    child.stdout?.on('data', onData);
+    child.stderr?.on('data', onData);
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      void untrack();
+      reject(err);
+    });
+    child.on('exit', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`${name} exited (code ${code ?? 'null'}) before emitting a URL`));
+    });
+  });
+}
+
+/**
+ * Probe whether a tunnel CLI is installed and runnable (`<cmd> --version`
+ * exits 0). Used as the `isAvailable()` gate by CLI-backed tunnel providers.
+ */
+export function isCliTunnelAvailable(cmd: string): Promise<boolean> {
+  return new Promise<boolean>((resolve) => {
+    const child = spawn(cmd, ['--version'], { stdio: 'ignore' });
+    child.once('error', () => resolve(false));
+    child.once('exit', (code) => resolve(code === 0));
+  });
+}

package/src/view-renderer.ts

@@ -93,6 +93,28 @@ export interface ViewRendererDef {
   validate(doc: ViewDoc): ReadonlyArray<ViewParseError>;
 }
 
+/**
+ * URL-scheme allow-list for agent-authored `href`/`src` values — the single
+ * canonical check, enforced at BOTH walls: parse/validate time
+ * (core's `parseView`/`validateDoc`) and render time (the web frontend
+ * re-checks before emitting an anchor/img; it keeps a verbatim copy in
+ * `plugin-channel-web/src/frontend/url-safety.ts` because the browser bundle
+ * cannot import the sdk root — keep the two in lockstep).
+ *
+ * Decision (audit A44): allowed schemes are `https:`, `http:`, `mailto:`,
+ * `tel:`, plus relative/fragment URLs; `data:` only as an `img src` and only
+ * `data:image/*`. Everything else — notably `javascript:`, `vbscript:`,
+ * `data:text/*` — is rejected. Views are designed to be shared with third
+ * parties, so a `javascript:` link is click-XSS on a shared surface.
+ */
+export function isSafeViewUrl(url: string, attr: string): boolean {
+  const u = url.trim().toLowerCase();
+  if (u.startsWith('javascript:') || u.startsWith('vbscript:')) return false;
+  if (u.startsWith('data:')) return attr === 'src' && u.startsWith('data:image/');
+  if (/^[a-z][a-z0-9+.-]*:/.test(u)) return /^(https?:|mailto:|tel:)/.test(u);
+  return true; // relative / fragment
+}
+
 const TONE = ['default', 'muted', 'success', 'warn', 'danger'] as const;
 const GAP = ['none', 'sm', 'md', 'lg'] as const;
 

package/src/workflow.ts

@@ -33,11 +33,34 @@ export interface WorkflowTrigger {
 /** How a failed step is handled: abort the workflow, skip past it, or retry. */
 export type WorkflowStepErrorMode = 'fail' | 'continue' | 'retry';
 
+/** Response format for logic steps (`bridge` only may use `plain`). */
+export type WorkflowLogicStepFormat = 'json' | 'plain';
+
+/**
+ * Bounded iteration node. `body` is an ordered list of step ids that run once
+ * per iteration; after each pass the LLM evaluates `condition` as a
+ * `then`=continue / `else`=stop predicate (same mechanism as a `condition`
+ * step). The loop stops when the predicate says stop OR after `maxIterations`
+ * passes — there is no unbounded path. The iteration cap is independent of the
+ * nested-workflow {@link WorkflowRunDeps.depth} guard: a loop body that calls
+ * nested workflows still obeys the executor's depth cap.
+ */
+export interface WorkflowLoopAction {
+  /** Ordered step ids run once per iteration (must resolve; ≥1). */
+  readonly body: ReadonlyArray<string>;
+  /** LLM predicate: `then` = run another iteration, `else` = stop. */
+  readonly condition: string;
+  /** Hard cap on iterations (1..50). Hitting it ends the loop cleanly. */
+  readonly maxIterations: number;
+}
+
 /**
  * One node in the DAG. Exactly one *action* key is set
- * (`skill` | `prompt` | `tool` | `workflow`). `input` is the templated prompt
- * for skill/prompt actions; `args` are the templated arguments for
- * tool/workflow actions. `needs` are the upstream step ids this step depends on.
+ * (`skill` | `prompt` | `tool` | `workflow` | `bridge` | `condition` | `switch`
+ * | `loop`). Logic steps run a single no-tools subagent turn; default response
+ * is JSON (`vars`, `branch`, optional `text`). `input` is the templated prompt
+ * for skill/prompt; `args` for tool/workflow; `bridge` / `condition` / `switch`
+ * hold the logic instruction text; `loop` holds a bounded iteration spec.
  */
 export interface WorkflowStep {
   readonly id: string;
@@ -45,14 +68,34 @@ export interface WorkflowStep {
   readonly prompt?: string;
   readonly tool?: string;
   readonly workflow?: string;
+  /** Extract/transform upstream data into `vars` (and optional `text`). */
+  readonly bridge?: string;
+  /** If/else gate: agent returns `{"branch":"then"|"else"}`. */
+  readonly condition?: string;
+  readonly then?: ReadonlyArray<string>;
+  readonly else?: ReadonlyArray<string>;
+  /** Multi-way gate: agent returns `{"branch":"<caseId>"}`. */
+  readonly switch?: string;
+  readonly cases?: Readonly<Record<string, ReadonlyArray<string>>>;
+  readonly default?: ReadonlyArray<string>;
+  /** Bounded iteration over `loop.body`, gated by an LLM predicate. */
+  readonly loop?: WorkflowLoopAction;
   readonly input?: string;
   readonly args?: Record<string, unknown>;
   readonly needs: ReadonlyArray<string>;
-  /** Condition DSL; when it evaluates false the step is skipped. */
+  /** Legacy deterministic guard DSL; prefer `condition`/`switch` for semantics. */
   readonly when?: string;
   readonly onError: WorkflowStepErrorMode;
   readonly retries: number;
   readonly label?: string;
+  /** `plain` only on `bridge`; `condition`/`switch` always require JSON. */
+  readonly format?: WorkflowLogicStepFormat;
+  /**
+   * When true on a `prompt` or `skill` step, the DAG pauses after the
+   * subagent's first turn so the operator can reply once; the step completes
+   * after a follow-up turn. Ignored on logic / `tool` / `workflow` steps.
+   */
+  readonly awaitInput?: boolean;
 }
 
 export interface WorkflowInputSpec {
@@ -67,6 +110,27 @@ export interface WorkflowDelivery {
   readonly inbox: boolean;
 }
 
+/** Visual editor metadata. Runtime executors must ignore this field. */
+export interface WorkflowUiLayoutNode {
+  readonly x: number;
+  readonly y: number;
+}
+
+export interface WorkflowUiViewport {
+  readonly x: number;
+  readonly y: number;
+  readonly zoom: number;
+}
+
+export interface WorkflowUiLayout {
+  readonly nodes: Record<string, WorkflowUiLayoutNode>;
+  readonly viewport?: WorkflowUiViewport;
+}
+
+export interface WorkflowUi {
+  readonly layout?: WorkflowUiLayout;
+}
+
 export interface Workflow {
   readonly name: string;
   readonly description: string;
@@ -80,6 +144,8 @@ export interface Workflow {
   readonly inputs: Record<string, WorkflowInputSpec>;
   readonly on?: WorkflowTrigger;
   readonly delivery?: WorkflowDelivery;
+  /** GUI-only metadata persisted with the YAML artifact. */
+  readonly ui?: WorkflowUi;
   /** Max steps to run concurrently in one ready-set round. */
   readonly concurrency: number;
   readonly steps: ReadonlyArray<WorkflowStep>;
@@ -104,6 +170,9 @@ export type WorkflowEventSubtype =
   | 'workflow_step_completed'
   | 'workflow_step_skipped'
   | 'workflow_step_failed'
+  | 'workflow_step_awaiting_input'
+  | 'workflow_paused'
+  | 'workflow_resumed'
   | 'workflow_completed'
   | 'workflow_failed';
 
@@ -134,7 +203,9 @@ export interface WorkflowRunDeps {
   readonly depth?: number;
 }
 
-export type WorkflowStepStatus = 'completed' | 'skipped' | 'failed';
+export type WorkflowStepStatus = 'completed' | 'skipped' | 'failed' | 'awaiting_input';
+
+export type WorkflowRunStatus = 'completed' | 'paused' | 'failed';
 
 export interface WorkflowStepResult {
   readonly id: string;
@@ -147,10 +218,16 @@ export interface WorkflowStepResult {
 
 export interface WorkflowRunResult {
   readonly ok: boolean;
+  readonly status: WorkflowRunStatus;
   readonly steps: ReadonlyArray<WorkflowStepResult>;
   /** Output of the terminal (sink) step(s) — what delivery sends. */
   readonly output: string;
   readonly error?: string;
+  /** Set when `status` is `paused` — use with workflow reply API. */
+  readonly runId?: string;
+  readonly pendingStepId?: string;
+  /** Child subagent session id for chat / permissions while paused. */
+  readonly interactionAgentId?: string;
 }
 
 /**

package/dist/voice.d.ts

@@ -1,36 +0,0 @@
-/**
- * Voice / transcription helpers shared across surfaces.
- *
- * The TUI's voice-input infrastructure used to inline the same logic
- * with a `Codex`-specific name baked in. Pulled out here as
- * *agnostic* helpers that take a transcriber name as input, so the
- * desktop, TUI, and any future channel can mirror the same flow:
- *
- *   - Is the session ready to transcribe? Check via the requirements
- *     API for a named transcriber. (`checkTranscriberReady`)
- *   - Activate any registered transcriber lazily. Returns the active
- *     transcriber instance. (`resolveTranscriber`)
- *   - "Just give me whatever works" — try a list of candidates in
- *     order, or fall back to the first registered one. (`pickFirstAvailableTranscriber`)
- */
-import type { ClientSession } from './client-session.js';
-import type { MoxxyRequirement, RequirementCheck } from './requirements.js';
-import type { Transcriber } from './transcriber.js';
-/** Probe whether a *named* transcriber is ready: registered, with any
- *  declared upstream requirements satisfied. The optional `requires`
- *  list lets channels gate on additional provider / auth runtimes
- *  (the Codex transcriber e.g. depends on the `openai-codex` provider
- *  + its OAuth runtime). */
-export declare function checkTranscriberReady(session: ClientSession, transcriberName: string, requires?: ReadonlyArray<MoxxyRequirement>): RequirementCheck;
-/** Activate a transcriber by name, lazily. Returns the active instance
- *  ready to `.transcribe(...)`. Throws if no such transcriber is
- *  registered, or a *different* one is already active. */
-export declare function resolveTranscriber(session: ClientSession, transcriberName: string): Transcriber;
-/** "Just pick a transcriber that works."
- *
- *  Tries each name in `candidates` in order — first one that can be
- *  activated wins. Returns null if none can be activated, so callers
- *  can degrade gracefully (hide their mic button, show a "no voice
- *  configured" tip, …) instead of throwing. */
-export declare function pickFirstAvailableTranscriber(session: ClientSession, candidates: ReadonlyArray<string>): Transcriber | null;
-//# sourceMappingURL=voice.d.ts.map

package/dist/voice.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"voice.d.ts","sourceRoot":"","sources":["../src/voice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAEjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;4BAI4B;AAC5B,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,MAAM,EACvB,QAAQ,GAAE,aAAa,CAAC,gBAAgB,CAAM,GAC7C,gBAAgB,CAqBlB;AAED;;0DAE0D;AAC1D,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,eAAe,EAAE,MAAM,GACtB,WAAW,CAcb;AAED;;;;;+CAK+C;AAC/C,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,GAChC,WAAW,GAAG,IAAI,CAepB"}