@moxxy/sdk 0.1.2 → 0.2.0

package/src/session-like.ts

@@ -1,7 +1,7 @@
 import type { MoxxyEvent, UserPromptAttachment } from './events.js';
 import type { SessionId, TurnId } from './ids.js';
 import type { EventLogReader } from './log.js';
-import type { ApprovalResolver } from './mode.js';
+import type { ApprovalResolver, ModeBadge } from './mode.js';
 import type { PermissionResolver } from './permission.js';
 import type { ModelDescriptor } from './provider.js';
 import type { ToolCompactPresentation } from './tool.js';
@@ -40,10 +40,23 @@ export interface SessionLogReader extends EventLogReader {
   subscribe(fn: (event: MoxxyEvent) => void | Promise<void>): () => void;
 }
 
-/** Serializable provider metadata (models + context windows) for display. */
+/** How a provider authenticates. UIs use this to decide whether to
+ *  show an API-key field or kick off an OAuth flow. */
+export type ProviderAuthKind = 'api-key' | 'oauth';
+
+/** Serializable provider metadata (models + context windows + auth)
+ *  for display. */
 export interface ProviderInfo {
   readonly name: string;
   readonly models: ReadonlyArray<ModelDescriptor>;
+  /** 'oauth' when the provider declares an oauth login on its plugin
+   *  definition, 'api-key' otherwise. Defaults to 'api-key' for
+   *  providers that don't declare. */
+  readonly authKind: ProviderAuthKind;
+  /** True when the provider's plugin can list its models live (e.g.
+   *  via /v1/models). Lets the desktop's model picker show a
+   *  "Fetch live" affordance only where it makes sense. */
+  readonly supportsLiveModelDiscovery: boolean;
 }
 
 /** Serializable tool metadata for status lines / slash menus / compact rendering. */
@@ -83,6 +96,13 @@ export interface SessionInfo {
   readonly activeProvider: string | null;
   readonly providers: ReadonlyArray<ProviderInfo>;
   readonly activeMode: string | null;
+  /**
+   * Presentation hint for the active mode, when it advertises one (see
+   * {@link ModeBadge}). Lets channels render a persistent accent badge for
+   * autonomous modes like goal mode. `null` when no mode is active or the
+   * active mode declares no badge.
+   */
+  readonly activeModeBadge: ModeBadge | null;
   readonly modes: ReadonlyArray<string>;
   readonly tools: ReadonlyArray<ToolInfo>;
   readonly skills: ReadonlyArray<SkillInfo>;
@@ -92,6 +112,69 @@ export interface SessionInfo {
   readonly hasTranscriber: boolean;
   /** Name of the active transcriber, or null. Lets a thin client proxy STT. */
   readonly activeTranscriber: string | null;
+  /** Whether any text-to-speech backend is registered. */
+  readonly hasSynthesizer: boolean;
+  /** Name of the active synthesizer, or null. Lets a thin client proxy TTS
+   *  (the desktop routes "Read aloud" through it; null → OS voice fallback). */
+  readonly activeSynthesizer: string | null;
+}
+
+/**
+ * Resolves a provider's stored credentials (vault tokens / API keys) into the
+ * config object `providers.setActive` needs. The host installs one on a local
+ * Session at boot; it is undefined across a `RemoteSession` transport (a closure
+ * can't cross the wire — the runner side resolves credentials there instead).
+ */
+export type CredentialResolver = (providerName: string) => Promise<Record<string, unknown>>;
+
+/** One server's status in {@link McpAdminView.listServers}. */
+export interface McpServerStatusView {
+  readonly name: string;
+  readonly enabled: boolean;
+  readonly connected: boolean;
+}
+
+/**
+ * The slice of the MCP admin API a channel needs to drive the MCP picker and
+ * status line. Present on a local Session when the MCP admin plugin is wired;
+ * a `RemoteSession` leaves {@link SessionLike.mcpAdmin} undefined and the UI
+ * degrades gracefully.
+ */
+export interface McpAdminView {
+  enableAndAttach(name: string): Promise<{ toolNames: ReadonlyArray<string> } | null>;
+  detach(name: string): Promise<boolean>;
+  listServers(): Promise<ReadonlyArray<McpServerStatusView>>;
+}
+
+/** One workflow's summary for the `/workflows` modal. */
+export interface WorkflowSummaryView {
+  readonly name: string;
+  readonly description: string;
+  readonly enabled: boolean;
+  readonly scope: string;
+  readonly steps: number;
+  /** Human-readable trigger summary, e.g. `cron(0 8 * * *)` or `on-demand`. */
+  readonly triggers: string;
+}
+
+/** Result of running a workflow from the modal. */
+export interface WorkflowRunView {
+  readonly ok: boolean;
+  readonly output: string;
+  readonly error?: string;
+  readonly steps: ReadonlyArray<{ readonly id: string; readonly status: string; readonly error?: 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.
+ */
+export interface WorkflowsView {
+  list(): Promise<ReadonlyArray<WorkflowSummaryView>>;
+  setEnabled(name: string, enabled: boolean): Promise<void>;
+  run(name: string): Promise<WorkflowRunView>;
 }
 
 /**
@@ -115,4 +198,19 @@ export interface SessionLike {
   /** Wire-friendly registry snapshot for rendering. */
   getInfo(): SessionInfo;
   close(reason?: string): Promise<void>;
+
+  /**
+   * Live runtime capabilities present only on an in-process Session; a
+   * `RemoteSession` thin client leaves them undefined, so callers MUST guard.
+   * For plain display prefer the serializable {@link getInfo} snapshot — these
+   * are for the mutate/guard paths a channel drives (provider switch, MCP picker).
+   */
+  /** Providers whose credentials resolved this session (live, mutable). */
+  readyProviders?: Set<string>;
+  /** Re-resolves a provider's credentials before `providers.setActive`. */
+  credentialResolver?: CredentialResolver;
+  /** MCP admin slice backing the MCP picker / status line. */
+  mcpAdmin?: McpAdminView;
+  /** Workflows slice backing the `/workflows` modal. */
+  workflows?: WorkflowsView;
 }

package/src/stuck-loop.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { createStuckLoopDetector } from './mode-helpers.js';
+
+describe('createStuckLoopDetector', () => {
+  it('trips on exact-input repeats at repeatThreshold', () => {
+    const d = createStuckLoopDetector(); // repeatThreshold 3
+    const input = { x: 1 };
+    expect(d.record('Read', input).stuck).toBe(false);
+    expect(d.record('Read', input).stuck).toBe(false);
+    const sig = d.record('Read', input);
+    expect(sig).toMatchObject({ stuck: true, count: 3, kind: 'exact' });
+  });
+
+  it('trips on same-target near-dups even when volatile args vary', () => {
+    const d = createStuckLoopDetector(); // nearThreshold 5
+    const url = 'https://example.com/big';
+    // Same url, different maxBytes each time — exact check never fires.
+    for (let i = 0; i < 4; i++) {
+      expect(d.record('web_fetch', { url, maxBytes: 1000 * (i + 1) }).stuck).toBe(false);
+    }
+    const sig = d.record('web_fetch', { url, maxBytes: 99_000 });
+    expect(sig).toMatchObject({ stuck: true, kind: 'near' });
+    expect(sig.count).toBeGreaterThanOrEqual(5);
+  });
+
+  it('does NOT trip on distinct targets (legit multi-source fetching)', () => {
+    const d = createStuckLoopDetector();
+    for (let i = 0; i < 7; i++) {
+      const sig = d.record('web_fetch', { url: `https://example.com/page-${i}`, maxBytes: 8000 });
+      expect(sig.stuck).toBe(false);
+    }
+  });
+
+  it('ignores near-dups for tools with no identity arg', () => {
+    const d = createStuckLoopDetector();
+    // No url/path/command field — near tracking is skipped; only exact applies.
+    for (let i = 0; i < 6; i++) {
+      const sig = d.record('think', { note: `step ${i}` });
+      expect(sig.stuck).toBe(false);
+    }
+  });
+});

package/src/synthesizer.ts

@@ -0,0 +1,67 @@
+/**
+ * Synthesizers convert text into spoken audio (text-to-speech). They are the
+ * symmetric counterpart to {@link Transcriber} (speech-to-text): a separate,
+ * swappable capability so a user can pair any text provider with a dedicated
+ * TTS backend (the OS voice, ElevenLabs, OpenAI, a local engine, …).
+ *
+ * Plugins register a `SynthesizerDef` via `PluginSpec.synthesizers`. The core
+ * `SynthesizerRegistry` holds them; surfaces that read aloud (the desktop's
+ * "Read aloud" button, a future voice channel) call
+ * `session.synthesizers.getActive()` (or `tryGetActive()`) to turn text into
+ * audio. There is at most one *active* synthesizer at a time; when none is
+ * active the caller degrades gracefully (the desktop falls back to the
+ * browser/OS `speechSynthesis`).
+ *
+ * The user swaps the active synthesizer by asking the agent ("use ElevenLabs
+ * for read-aloud") — there is no settings UI. The agent activates a registered
+ * synthesizer (a plugin it authored/installed self-activates in `onInit`, or it
+ * calls a set-active tool); switching back to the OS voice deactivates it.
+ */
+
+export interface SynthesizeOptions {
+  /** Preferred voice id/name, when the backend supports selection. */
+  readonly voice?: string;
+  /** BCP-47 language hint (e.g. `en`, `pl`). */
+  readonly language?: string;
+  /** Speaking rate multiplier (1.0 = normal), when supported. */
+  readonly rate?: number;
+  /** Cancellation signal — callers propagate a stop/abort here. */
+  readonly signal?: AbortSignal;
+}
+
+export interface SynthesisResult {
+  /** Encoded audio bytes ready to play (e.g. an mp3/wav/ogg payload). */
+  readonly audio: Uint8Array;
+  /** MIME type of {@link audio}, e.g. `audio/mpeg`, `audio/wav`, `audio/ogg`. */
+  readonly mimeType: string;
+}
+
+export interface Synthesizer {
+  /** Short stable name, e.g. `elevenlabs`. */
+  readonly name: string;
+  synthesize(text: string, opts?: SynthesizeOptions): Promise<SynthesisResult>;
+}
+
+/**
+ * Context handed to {@link SynthesizerDef.create} when the registry activates a
+ * synthesizer. `getSecret` reads a vault secret (the API key) the same way a
+ * tool handler does via `ctx.getSecret` — so an authored TTS plugin never has
+ * to touch `process.env`, and the key never enters the model's context.
+ */
+export interface SynthesizerCreateContext {
+  /** Per-synthesizer config (e.g. from `session.synthesizers.setActive(name, config)`). */
+  readonly config: Record<string, unknown>;
+  /** Read a named vault secret, or null if unset / no vault is wired. */
+  readonly getSecret?: (name: string) => Promise<string | null>;
+}
+
+/**
+ * Plugin-side definition. Mirrors `TranscriberDef`: a `create(ctx)` factory the
+ * registry calls when this synthesizer is activated.
+ */
+export interface SynthesizerDef {
+  readonly name: string;
+  /** Optional human-readable label for UI surfaces. */
+  readonly displayName?: string;
+  create(ctx: SynthesizerCreateContext): Synthesizer;
+}

package/src/tool.ts

@@ -127,6 +127,19 @@ export interface ToolContext {
    * `caps.subprocess` + optional `caps.commands` allowlist.
    */
   readonly exec?: BrokeredExec;
+  /**
+   * Read a named secret from the host's secret store (the vault) at call
+   * time. Present when the session is wired with a vault-backed resolver
+   * (the CLI/runner does this). Returns the plaintext value, or `null` if
+   * no such secret exists.
+   *
+   * This is the blessed way for a tool/plugin to consume an API key or
+   * token: the plaintext only ever reaches the handler that asks for it —
+   * it is never placed in the model's context or in `process.env`. Store
+   * the secret once via `/vault set NAME …` (or the desktop Secrets UI),
+   * then read it here, e.g. `const key = await ctx.getSecret('ELEVENLABS_API_KEY')`.
+   */
+  readonly getSecret?: (name: string) => Promise<string | null>;
 }
 
 /**

package/src/voice.ts

@@ -0,0 +1,103 @@
+/**
+ * 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,
+  RequirementIssue,
+} 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 function checkTranscriberReady(
+  session: ClientSession,
+  transcriberName: string,
+  requires: ReadonlyArray<MoxxyRequirement> = [],
+): RequirementCheck {
+  const baseline: ReadonlyArray<MoxxyRequirement> = [
+    { kind: 'transcriber', name: transcriberName },
+    ...requires,
+  ];
+  const check = session.requirements.check(baseline);
+  const activeName = session.transcribers.getActiveName();
+  if (!activeName || activeName === transcriberName) return check;
+
+  const conflict: RequirementIssue = {
+    requirement: {
+      kind: 'transcriber',
+      name: transcriberName,
+      state: 'active',
+      hint: `Switch active transcriber to ${transcriberName}.`,
+    },
+    code: 'inactive',
+    message: `Required active transcriber ${transcriberName}; active is ${activeName}`,
+    hint: `Switch active transcriber to ${transcriberName}.`,
+  };
+  return { ready: false, issues: [conflict, ...check.issues] };
+}
+
+/** 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 function resolveTranscriber(
+  session: ClientSession,
+  transcriberName: string,
+): Transcriber {
+  const activeName = session.transcribers.getActiveName();
+  if (activeName && activeName !== transcriberName) {
+    throw new Error(
+      `Another transcriber is already active: ${activeName}.`,
+    );
+  }
+  if (activeName === transcriberName) return session.transcribers.getActive();
+  if (session.transcribers.has(transcriberName)) {
+    return session.transcribers.setActive(transcriberName);
+  }
+  throw new Error(
+    `No transcriber registered as ${transcriberName}. Configure one via your moxxy plugins.`,
+  );
+}
+
+/** "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 function pickFirstAvailableTranscriber(
+  session: ClientSession,
+  candidates: ReadonlyArray<string>,
+): Transcriber | null {
+  // If something's already active, just hand that back — never fight
+  // a user-chosen activation.
+  const existing = session.transcribers.tryGetActive();
+  if (existing) return existing;
+  for (const name of candidates) {
+    try {
+      return resolveTranscriber(session, name);
+    } catch {
+      // Wrong-active errors don't apply here (we just returned early),
+      // so any throw is "this candidate isn't registered" — keep
+      // trying.
+    }
+  }
+  return null;
+}

package/src/workflow.ts

@@ -0,0 +1,165 @@
+/**
+ * Workflows — saved, parameterized, schedulable/event-triggered DAGs whose
+ * steps run a skill, a free-form prompt, a tool, or a nested workflow, piping
+ * each step's output into the next. A workflow is an *artifact* (authored like
+ * a skill, discovered from disk); the strategy that *executes* it is a
+ * swappable block — {@link WorkflowExecutorDef} — registered into the
+ * `WorkflowExecutorRegistry` and selected by name, mirroring modes/compactors.
+ *
+ * These are the shared structural types. The zod schema that validates
+ * on-disk YAML lives in `@moxxy/plugin-workflows`; its parsed output is
+ * assignable to {@link Workflow}.
+ */
+
+import type { Skill } from './skill.js';
+import type { SubagentSpawner } from './subagent.js';
+
+/** What fires a workflow. Omit `on` entirely for an on-demand-only workflow. */
+export interface WorkflowTrigger {
+  /** Cron / one-shot time trigger, dispatched by `@moxxy/plugin-scheduler`. */
+  readonly schedule?: {
+    readonly cron?: string;
+    readonly runAt?: number | string;
+    readonly timeZone?: string;
+  };
+  /** Run when the named workflow(s) complete successfully (EventLog-driven). */
+  readonly afterWorkflow?: string | ReadonlyArray<string>;
+  /** Run when files matching the glob(s) under cwd change (fs.watch-driven). */
+  readonly fileChanged?: string | ReadonlyArray<string>;
+  /** Named webhook provider whose delivery fires this workflow. */
+  readonly webhook?: string;
+}
+
+/** How a failed step is handled: abort the workflow, skip past it, or retry. */
+export type WorkflowStepErrorMode = 'fail' | 'continue' | 'retry';
+
+/**
+ * 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.
+ */
+export interface WorkflowStep {
+  readonly id: string;
+  readonly skill?: string;
+  readonly prompt?: string;
+  readonly tool?: string;
+  readonly workflow?: string;
+  readonly input?: string;
+  readonly args?: Record<string, unknown>;
+  readonly needs: ReadonlyArray<string>;
+  /** Condition DSL; when it evaluates false the step is skipped. */
+  readonly when?: string;
+  readonly onError: WorkflowStepErrorMode;
+  readonly retries: number;
+  readonly label?: string;
+}
+
+export interface WorkflowInputSpec {
+  readonly default?: unknown;
+  readonly description?: string;
+}
+
+export interface WorkflowDelivery {
+  /** Soft hint for delivery target — e.g. "telegram", "inbox". */
+  readonly channel?: string;
+  /** Also drop the final output into `~/.moxxy/inbox/`. Default true. */
+  readonly inbox: boolean;
+}
+
+export interface Workflow {
+  readonly name: string;
+  readonly description: string;
+  readonly version: number;
+  /**
+   * When false the workflow is inert: triggers (schedule/event) never fire it
+   * and it is excluded from auto-runs, but it stays listable and can still be
+   * run explicitly. Toggled from the `/workflows` command.
+   */
+  readonly enabled: boolean;
+  readonly inputs: Record<string, WorkflowInputSpec>;
+  readonly on?: WorkflowTrigger;
+  readonly delivery?: WorkflowDelivery;
+  /** Max steps to run concurrently in one ready-set round. */
+  readonly concurrency: number;
+  readonly steps: ReadonlyArray<WorkflowStep>;
+}
+
+/** Minimal tool surface a step needs — structurally a subset of `ToolRegistry`. */
+export interface WorkflowToolRunner {
+  get(name: string): unknown | undefined;
+  execute(name: string, input: unknown, signal: AbortSignal): Promise<unknown>;
+}
+
+/** Look up sibling artifacts by name during a run. */
+export interface WorkflowLookup {
+  skill(name: string): Skill | undefined;
+  workflow(name: string): Workflow | undefined;
+}
+
+/** Lifecycle subtypes an executor emits as `plugin_event`s (mirrors plan_*). */
+export type WorkflowEventSubtype =
+  | 'workflow_started'
+  | 'workflow_step_started'
+  | 'workflow_step_completed'
+  | 'workflow_step_skipped'
+  | 'workflow_step_failed'
+  | 'workflow_completed'
+  | 'workflow_failed';
+
+/**
+ * Everything an executor needs to run a workflow, supplied by the caller.
+ * The in-turn `workflow_run` tool wires `spawner` from `ctx.subagents`; the
+ * autonomous runner builds one from an isolated session. Kept free of core
+ * imports so the executor stays in a plugin.
+ */
+export interface WorkflowRunDeps {
+  readonly spawner: SubagentSpawner;
+  readonly tools: WorkflowToolRunner;
+  readonly lookup: WorkflowLookup;
+  readonly signal: AbortSignal;
+  /** Resolved input values (defaults already applied) for this run. */
+  readonly inputs?: Record<string, unknown>;
+  /** Free-form description of what fired the run (for `{{ trigger }}`). */
+  readonly trigger?: string;
+  /** Wall-clock source. Injected so tests are deterministic. */
+  readonly now?: () => number;
+  /** Emit a workflow lifecycle event. No-op when omitted. */
+  readonly emit?: (subtype: WorkflowEventSubtype, payload: unknown) => void | Promise<void>;
+  readonly logger?: {
+    warn?(msg: string, meta?: Record<string, unknown>): void;
+    info?(msg: string, meta?: Record<string, unknown>): void;
+  };
+  /** Nested-workflow recursion depth; executors guard against runaway nesting. */
+  readonly depth?: number;
+}
+
+export type WorkflowStepStatus = 'completed' | 'skipped' | 'failed';
+
+export interface WorkflowStepResult {
+  readonly id: string;
+  readonly status: WorkflowStepStatus;
+  readonly output: string;
+  readonly error?: string;
+  readonly startedAt: number;
+  readonly endedAt: number;
+}
+
+export interface WorkflowRunResult {
+  readonly ok: boolean;
+  readonly steps: ReadonlyArray<WorkflowStepResult>;
+  /** Output of the terminal (sink) step(s) — what delivery sends. */
+  readonly output: string;
+  readonly error?: string;
+}
+
+/**
+ * A swappable workflow-execution strategy. v1 ships one (`dag`); a plugin can
+ * register alternatives (parallel-heavy, dry-run, …) and the active one is
+ * selected by name via `session.workflowExecutors.setActive(name)`.
+ */
+export interface WorkflowExecutorDef {
+  readonly name: string;
+  readonly description?: string;
+  run(workflow: Workflow, deps: WorkflowRunDeps): Promise<WorkflowRunResult>;
+}

package/dist/command-sync.d.ts

@@ -1,23 +0,0 @@
-export declare const COMMAND_SESSION_ACTION_SUBTYPE: "command.session_action";
-export declare const COMMAND_STATE_CHANGED_SUBTYPE: "command.state_changed";
-export type CommandOriginChannel = 'tui' | 'office' | (string & {});
-export type CommandTarget = 'session';
-export interface CommandSyncBasePayload {
-    readonly command: string;
-    readonly target: CommandTarget;
-    readonly origin_channel: CommandOriginChannel;
-    readonly origin_id: string;
-    readonly notice?: string;
-}
-export interface CommandSessionActionPayload extends CommandSyncBasePayload {
-    readonly action: 'new';
-}
-export interface CommandStateChangedPayload extends CommandSyncBasePayload {
-    readonly action: 'model_changed' | 'loop_changed';
-    readonly provider?: string;
-    readonly model?: string;
-    readonly loop?: string;
-}
-export declare function isCommandSessionActionPayload(value: unknown): value is CommandSessionActionPayload;
-export declare function isCommandStateChangedPayload(value: unknown): value is CommandStateChangedPayload;
-//# sourceMappingURL=command-sync.d.ts.map

package/dist/command-sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"command-sync.d.ts","sourceRoot":"","sources":["../src/command-sync.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,EAAG,wBAAiC,CAAC;AAChF,eAAO,MAAM,6BAA6B,EAAG,uBAAgC,CAAC;AAE9E,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC;AAEtC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA4B,SAAQ,sBAAsB;IACzE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;CACxB;AAED,MAAM,WAAW,0BAA2B,SAAQ,sBAAsB;IACxE,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,cAAc,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAqBD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,2BAA2B,CAGtC;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,0BAA0B,CAcrC"}

package/dist/command-sync.js

@@ -1,36 +0,0 @@
-export const COMMAND_SESSION_ACTION_SUBTYPE = 'command.session_action';
-export const COMMAND_STATE_CHANGED_SUBTYPE = 'command.state_changed';
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
-}
-function hasBasePayload(value) {
-    return (typeof value.command === 'string' &&
-        value.command.trim().length > 0 &&
-        value.target === 'session' &&
-        typeof value.origin_channel === 'string' &&
-        value.origin_channel.trim().length > 0 &&
-        typeof value.origin_id === 'string' &&
-        value.origin_id.trim().length > 0 &&
-        (value.notice === undefined || typeof value.notice === 'string'));
-}
-export function isCommandSessionActionPayload(value) {
-    const record = asRecord(value);
-    return Boolean(record && hasBasePayload(record) && record.action === 'new');
-}
-export function isCommandStateChangedPayload(value) {
-    const record = asRecord(value);
-    if (!record || !hasBasePayload(record))
-        return false;
-    if (record.action === 'model_changed') {
-        return ((record.provider === undefined || typeof record.provider === 'string') &&
-            typeof record.model === 'string' &&
-            record.model.trim().length > 0);
-    }
-    if (record.action === 'loop_changed') {
-        return typeof record.loop === 'string' && record.loop.trim().length > 0;
-    }
-    return false;
-}
-//# sourceMappingURL=command-sync.js.map

package/dist/command-sync.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"command-sync.js","sourceRoot":"","sources":["../src/command-sync.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,8BAA8B,GAAG,wBAAiC,CAAC;AAChF,MAAM,CAAC,MAAM,6BAA6B,GAAG,uBAAgC,CAAC;AAwB9E,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAChE,CAAC,CAAC,KAAgC;QAClC,CAAC,CAAC,IAAI,CAAC;AACX,CAAC;AAED,SAAS,cAAc,CAAC,KAA8B;IACpD,OAAO,CACL,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ;QACjC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;QAC/B,KAAK,CAAC,MAAM,KAAK,SAAS;QAC1B,OAAO,KAAK,CAAC,cAAc,KAAK,QAAQ;QACxC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;QACtC,OAAO,KAAK,CAAC,SAAS,KAAK,QAAQ;QACnC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;QACjC,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,KAAK,CAAC,MAAM,KAAK,QAAQ,CAAC,CACjE,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,6BAA6B,CAC3C,KAAc;IAEd,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/B,OAAO,OAAO,CAAC,MAAM,IAAI,cAAc,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;AAC9E,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC1C,KAAc;IAEd,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/B,IAAI,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrD,IAAI,MAAM,CAAC,MAAM,KAAK,eAAe,EAAE,CAAC;QACtC,OAAO,CACL,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,CAAC;YACtE,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ;YAChC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAC/B,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,KAAK,cAAc,EAAE,CAAC;QACrC,OAAO,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/loop-helpers.d.ts

@@ -1,68 +0,0 @@
-import type { ProviderMessage } from './provider.js';
-import type { LoopContext } from './loop.js';
-import type { StopReason } from './provider-utils.js';
-import type { Skill } from './skill.js';
-/**
- * Shared bits used by every loop strategy: a typed tool-use struct and a
- * common stream-collection helper that runs `onBeforeProviderCall` hooks
- * and reduces a provider stream down to `{text, toolUses, stopReason}`.
- *
- * Lives in core (not in each loop package) so a new loop strategy stays
- * consistent — and so behavioral fixes here propagate. Previously
- * loop-plan-execute had its own copy that skipped the hook (audit bug).
- */
-export interface CollectedToolUse {
-    readonly id: string;
-    readonly name: string;
-    readonly input: unknown;
-}
-/**
- * Compose a model-facing system prompt that includes any base prompt
- * plus a COMPACT skill index (name + description + triggers only).
- *
- * Lazy-loading design: the body is intentionally NOT inlined. The model
- * matches user intent against the description/triggers, then calls the
- * `load_skill` tool to fetch the body of the skill it picked. This keeps
- * the system prompt small even with many skills installed and avoids
- * paying for skill bodies the model never actually follows.
- */
-export declare function buildSystemPromptWithSkills(baseSystemPrompt: string | undefined, skills: ReadonlyArray<Skill>): string | undefined;
-export interface ProjectMessagesOptions {
-    /** Optional system prompt; emitted as the first message when set. */
-    readonly systemPrompt?: string;
-    /** Optional trailing user message — useful for plan-execute's "Focus on this step now: X". */
-    readonly trailingUserText?: string;
-}
-/**
- * Project the session's event log to a flat list of ProviderMessages
- * suitable for handing to `provider.stream`. Used by every loop strategy.
- *
- * Handles user_prompt, assistant_message, tool_call_requested (grouped
- * into a single assistant message of tool_use blocks), and tool_result.
- * Other event types are passed through as a no-op.
- *
- * Note: this is the minimal projection used by loop strategies. Core's
- * `selectMessages` is a richer variant that also honors compaction events
- * and attachments; the simpler form here lives in the SDK so loop plugins
- * stay independent of core.
- */
-export declare function projectMessagesFromLog(ctx: Pick<LoopContext, 'log'>, opts?: ProjectMessagesOptions): ProviderMessage[];
-export interface StreamResult {
-    readonly text: string;
-    readonly toolUses: ReadonlyArray<CollectedToolUse>;
-    readonly stopReason: StopReason;
-    readonly error: {
-        readonly message: string;
-        readonly retryable: boolean;
-    } | null;
-}
-/**
- * Pulls a provider stream, emits `assistant_chunk` events for text deltas,
- * collects tool_use blocks, and returns the final `{text, toolUses, stopReason}`.
- * Runs `onBeforeProviderCall` lifecycle hooks before the call.
- */
-export declare function collectProviderStream(ctx: LoopContext, messages: ReadonlyArray<ProviderMessage>, opts?: {
-    iteration?: number;
-    includeTools?: boolean;
-}): Promise<StreamResult>;
-//# sourceMappingURL=loop-helpers.d.ts.map