@moxxy/sdk 0.1.2 → 0.1.3

package/src/resolvers.ts

@@ -0,0 +1,164 @@
+import type {
+  PendingToolCall,
+  PermissionContext,
+  PermissionDecision,
+  PermissionResolver,
+  PermissionRule,
+} from './permission.js';
+
+export const autoAllowResolver: PermissionResolver = {
+  name: 'auto-allow',
+  async check(): Promise<PermissionDecision> {
+    return { mode: 'allow', reason: 'auto-allow resolver (test mode)' };
+  },
+};
+
+export const denyByDefaultResolver: PermissionResolver = {
+  name: 'deny-by-default',
+  async check(): Promise<PermissionDecision> {
+    return { mode: 'deny', reason: 'No interactive resolver available in headless mode. Use --allow-tools or permissions.json.' };
+  },
+};
+
+export interface CallbackResolverOptions {
+  readonly name?: string;
+  readonly callback: (call: PendingToolCall, ctx: PermissionContext) => Promise<PermissionDecision>;
+}
+
+export function createCallbackResolver(opts: CallbackResolverOptions): PermissionResolver {
+  return {
+    name: opts.name ?? 'callback',
+    check: opts.callback,
+  };
+}
+
+export function createAllowListResolver(toolNames: ReadonlyArray<string>): PermissionResolver {
+  const allowed = new Set(toolNames);
+  return {
+    name: 'allow-list',
+    async check(call) {
+      if (allowed.has(call.name)) return { mode: 'allow_session', reason: 'allow-list' };
+      return { mode: 'deny', reason: `Tool '${call.name}' not in allow-list` };
+    },
+  };
+}
+
+export type PermissionPromptHandler = (
+  call: PendingToolCall,
+  ctx: PermissionContext,
+) => Promise<PermissionDecision>;
+
+export interface DeferredPermissionResolverOptions {
+  readonly prompt: PermissionPromptHandler;
+  readonly name?: string;
+  readonly sessionAllows?: Set<string>;
+}
+
+export interface DeferredPermissionResolver extends PermissionResolver {
+  /**
+   * Resolve all in-flight prompts with `deny`. Call from a channel's `stop`
+   * so a pending permission prompt doesn't hang forever when the host UI
+   * unmounts (the TUI bug the audit flagged).
+   */
+  abortAll(reason?: string): void;
+}
+
+/**
+ * Resolver for channels that defer permission decisions to an external UI
+ * (Ink dialog, Telegram inline keyboard, web form). Wraps a `prompt`
+ * callback with:
+ *   - sessionAllows shortcut — `allow_session` decisions skip subsequent
+ *     prompts for the same tool name.
+ *   - in-flight tracking — `abortAll()` resolves pending prompts with
+ *     `deny`, so the channel can shut down cleanly without hangs.
+ */
+export function createDeferredPermissionResolver(
+  opts: DeferredPermissionResolverOptions,
+): DeferredPermissionResolver {
+  const sessionAllows = opts.sessionAllows ?? new Set<string>();
+  const pending = new Set<(d: PermissionDecision) => void>();
+  return {
+    name: opts.name ?? 'deferred',
+    async check(call, ctx) {
+      if (sessionAllows.has(call.name)) {
+        return { mode: 'allow_session', reason: 'allow_session previously granted' };
+      }
+      const decision = await new Promise<PermissionDecision>((resolve) => {
+        pending.add(resolve);
+        opts.prompt(call, ctx).then(
+          (d) => {
+            pending.delete(resolve);
+            resolve(d);
+          },
+          (err) => {
+            pending.delete(resolve);
+            resolve({ mode: 'deny', reason: err instanceof Error ? err.message : String(err) });
+          },
+        );
+      });
+      // Both allow_session and allow_always should skip future prompts for
+      // the same tool within this resolver instance. allow_always
+      // additionally signals to the caller (via the decision flag) that
+      // the rule should be persisted to ~/.moxxy/permissions.json — but
+      // that persistence isn't our job; the channel does it when wiring
+      // up the dialog.
+      if (decision.mode === 'allow_session' || decision.mode === 'allow_always') {
+        sessionAllows.add(call.name);
+      }
+      return decision;
+    },
+    abortAll(reason = 'channel closed') {
+      for (const r of pending) r({ mode: 'deny', reason });
+      pending.clear();
+    },
+  };
+}
+
+/**
+ * Evaluate a tool's OWN declared {@link PermissionRule} against a call.
+ *
+ * Tools can ship a `permission` rule to express their author's policy — e.g.
+ * `reload_skills` / `load_tool` declare `{ action: 'allow' }` because they're
+ * safe, internal, idempotent operations that should never prompt. That rule
+ * was previously stored on the ToolDef but never consulted, so in headless
+ * runs (where the channel resolver denies by default) even these safe tools
+ * were blocked. The session resolver now consults this BETWEEN the user's
+ * `permissions.json` policy and the channel resolver, so:
+ *
+ *   user policy (deny/allow)  >  tool-declared rule  >  channel resolver
+ *
+ * Returns a decision for a matching `allow`/`deny` rule, or `null` to defer
+ * (no rule, pattern didn't match, or `action: 'prompt'` — the interactive
+ * resolver should handle those).
+ */
+export function evaluateToolRule(
+  rule: PermissionRule | undefined,
+  call: PendingToolCall,
+): PermissionDecision | null {
+  if (!rule || !toolRuleMatches(rule, call)) return null;
+  switch (rule.action) {
+    case 'allow':
+      return { mode: 'allow', reason: rule.reason ?? 'tool-declared allow' };
+    case 'deny':
+      return { mode: 'deny', reason: rule.reason ?? 'tool-declared deny' };
+    case 'prompt':
+      return null; // defer to the interactive resolver
+  }
+}
+
+function toolRuleMatches(rule: PermissionRule, call: PendingToolCall): boolean {
+  const p = rule.pattern;
+  if (!p) return true; // no pattern → applies to every call of this tool
+  if (p.name !== undefined && !patternMatch(p.name, call.name)) return false;
+  if (p.inputMatches) {
+    const input = (call.input ?? {}) as Record<string, unknown>;
+    for (const [key, matcher] of Object.entries(p.inputMatches)) {
+      if (!patternMatch(matcher, String(input[key] ?? ''))) return false;
+    }
+  }
+  return true;
+}
+
+function patternMatch(pattern: string | RegExp, candidate: string): boolean {
+  return pattern instanceof RegExp ? pattern.test(candidate) : pattern === candidate;
+}

package/src/session-like.ts

@@ -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. */
@@ -94,6 +107,64 @@ export interface SessionInfo {
   readonly activeTranscriber: 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>;
+}
+
 /**
  * The session surface a `Channel` depends on, decoupled from whether the
  * session runs in-process (`@moxxy/core`'s `Session`) or is a thin-client
@@ -115,4 +186,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/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"}