@kodax-ai/kodax 0.7.41 → 0.7.43

package/dist/sdk-session.d.ts

@@ -0,0 +1,176 @@
+import { S as SessionData, F as FileSessionStorage } from './types-chunks/storage.d-DPAEX7zS.js';
+import './types-chunks/types.d-mM8vqvhT.js';
+import './types-chunks/types.d-B1uGoVTE.js';
+
+/**
+ * FEATURE_173 Part B (v0.7.42) — Session Management Public SDK.
+ *
+ * Thin facades over FileSessionStorage + discoverInstances. All methods
+ * NEVER throw — missing sessions return null, blocked operations return
+ * an error envelope, missing directories return empty arrays / no-op
+ * watchers.
+ *
+ * The `@kodax-ai/kodax/session` SDK subpath re-exports this module.
+ */
+
+interface SessionSummary {
+    readonly id: string;
+    readonly title: string;
+    readonly msgCount: number;
+    readonly createdAt?: string;
+    readonly runtimeInfo?: {
+        workspaceRoot?: string;
+        gitRoot?: string;
+    };
+}
+interface ListSessionsOptions {
+    /**
+     * Alias for gitRoot; backwards-compat with KodaX Space terminology.
+     * When provided, list() is scoped to sessions from this project root.
+     */
+    readonly projectRoot?: string;
+    /**
+     * Which session scopes to include.
+     * - 'user' (default): only user-initiated sessions.
+     * - 'managed-task-worker': only managed-task worker sessions.
+     * - 'all': no scope filter.
+     */
+    readonly scope?: 'user' | 'managed-task-worker' | 'all';
+    /**
+     * Whether to include archived sessions (filename starts with `archived-`).
+     * Default false — no archived sessions exist today; reserved for future use.
+     */
+    readonly includeArchived?: boolean;
+    /** Maximum number of sessions to return. Default 50. */
+    readonly limit?: number;
+    /**
+     * ISO date string — return only sessions whose createdAt is before this
+     * timestamp. Applied after list + scope filtering.
+     */
+    readonly before?: string;
+}
+type WatchSessionsCallback = (event: {
+    kind: 'change' | 'add' | 'remove';
+    sessionId: string;
+}) => void;
+interface SessionManager {
+    listSessions: typeof listSessions;
+    loadSession: typeof loadSession;
+    forkSession: typeof forkSession;
+    rewindSession: typeof rewindSession;
+    setActiveEntry: typeof setActiveEntry;
+    deleteSession: typeof deleteSession;
+    listRunningSessions: typeof listRunningSessions;
+    watchSessions: typeof watchSessions;
+    /**
+     * v0.7.43 — the raw write-side storage instance. SDK embedders pass
+     * this into `runKodaX({ session: { id, scope, storage } })` so the
+     * SA / AMA loops write per-turn JSONL snapshots to disk. Without an
+     * injected storage, `saveSessionSnapshot` is a silent no-op and the
+     * sessions directory stays empty regardless of `session.id`.
+     *
+     * See {@link FileSessionStorage} for the concrete implementation and
+     * `docs/SDK_EMBEDDER_GUIDE.md` §6 for the end-to-end recipe.
+     */
+    storage: FileSessionStorage;
+}
+/**
+ * List sessions, optionally filtered by scope, limit, and date.
+ * NEVER throws. Returns [] when the sessions directory is empty or missing.
+ */
+declare function listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
+/**
+ * Load full session data by ID.
+ * Returns null for a missing session. NEVER throws.
+ */
+declare function loadSession(id: string): Promise<SessionData | null>;
+/**
+ * Fork a session at an optional selector.
+ * Returns null for a missing session. NEVER throws.
+ */
+declare function forkSession(id: string, opts?: {
+    selector?: string;
+    sessionId?: string;
+    title?: string;
+}): Promise<{
+    sessionId: string;
+    data: SessionData;
+} | null>;
+/**
+ * Rewind a session to a previous user entry.
+ * Returns null for a missing session. NEVER throws.
+ */
+declare function rewindSession(id: string, opts?: {
+    selector?: string;
+}): Promise<SessionData | null>;
+/**
+ * Set the active lineage entry by selector.
+ * Returns null for a missing session. NEVER throws.
+ */
+declare function setActiveEntry(id: string, selector: string): Promise<SessionData | null>;
+interface RunningSessionInfo {
+    readonly pid: number;
+    readonly startedAt: number;
+    readonly cwd: string;
+    /**
+     * v0.7.43 — populated from `PersistedSessionState.sessionId`, published
+     * by the REPL after `createInteractiveContext`. Remains `undefined` for
+     * a brief window during a peer's bootstrap (before the first sessionId
+     * is generated) and for peers running pre-v0.7.43 binaries; consumers
+     * MUST handle `undefined`.
+     */
+    readonly sessionId: string | undefined;
+}
+/**
+ * Returns live KodaX sibling instances (excluding this process).
+ * Uses discoverInstances() from @kodax-ai/agent (FEATURE_125 Team Mode).
+ * NEVER throws. Returns [] when no instances directory exists.
+ */
+declare function listRunningSessions(): Promise<RunningSessionInfo[]>;
+type DeleteSessionResult = {
+    ok: true;
+} | {
+    error: {
+        code: 'session_running';
+        runningProcess: {
+            pid: number;
+            startedAt: number;
+        };
+    };
+};
+/**
+ * Delete a session by ID.
+ * Returns { ok: true } on success (including when the session doesn't exist).
+ * Returns an error envelope when the session is currently running.
+ * NEVER throws.
+ */
+declare function deleteSession(id: string): Promise<DeleteSessionResult>;
+/**
+ * Watch the sessions directory for changes.
+ * Returns { close() } that stops the watcher / poll interval.
+ *
+ * Platform branches:
+ * - POSIX: fs.watch() with 100ms debounce.
+ * - Windows: readdir poll every 1000ms, diffed against a snapshot.
+ *
+ * NEVER throws — if the directory doesn't exist the watcher is a no-op
+ * until the directory is created.
+ */
+declare function watchSessions(cb: WatchSessionsCallback): {
+    close: () => void;
+};
+/**
+ * Factory that returns an object with all session management methods bound.
+ *
+ * v0.7.43 (FEATURE_173 Part B follow-up) — the `sessionsDir` override is
+ * now honored. When provided, all read/write/watch operations go through
+ * that directory instead of the module-load-frozen `KODAX_SESSIONS_DIR`.
+ * `listRunningSessions` still consults the agent-config-home instances
+ * directory (sibling-process awareness is not scoped per sessions dir).
+ */
+declare function createSessionManager(opts?: {
+    sessionsDir?: string;
+}): SessionManager;
+
+export { createSessionManager, deleteSession, forkSession, listRunningSessions, listSessions, loadSession, rewindSession, setActiveEntry, watchSessions };
+export type { DeleteSessionResult, ListSessionsOptions, RunningSessionInfo, SessionManager, SessionSummary, WatchSessionsCallback };

package/dist/sdk-session.js

@@ -0,0 +1,2 @@
+// @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
+import{bc as s,cc as e,dc as n,ec as i,fc as o,gc as t,hc as S,ic as a,jc as r}from"./chunks/chunk-UG4262JI.js";import"./chunks/chunk-YMRZBS4G.js";import"./chunks/chunk-IYSK7LUK.js";import"./chunks/chunk-EVIDQWMF.js";import"./chunks/chunk-7G5PSL6C.js";import"./chunks/chunk-K75O2CAE.js";import"./chunks/chunk-VHKAJDQD.js";import"./chunks/chunk-V4WSBIXB.js";export{r as createSessionManager,S as deleteSession,n as forkSession,t as listRunningSessions,s as listSessions,e as loadSession,i as rewindSession,o as setActiveEntry,a as watchSessions};

package/dist/sdk-skills.d.ts

@@ -116,12 +116,68 @@ interface ISkillRegistry {
     /** Number of discovered skills */
     readonly size: number;
 }
+/**
+ * v0.7.42 — SDK-embedder hook for `!`cmd`` dynamic context resolution.
+ *
+ * Receives the literal command string and the working directory the resolver
+ * would have used. Must return the command's text output (which the resolver
+ * splices into the skill markdown in place of the `!`cmd`` token), or throw
+ * to deny.
+ *
+ * **Trust boundary**: when the KodaX SDK is embedded inside a host app
+ * (e.g. KodaX Space, IDE extensions), the host typically mediates shell
+ * execution through a permission broker so the end user can approve / deny
+ * each command. Without this hook, `VariableResolver` directly `execSync`s
+ * commands using its own built-in whitelist — bypassing the host's broker
+ * and producing OS side-effects the user never saw.
+ *
+ * Embedders should route here to:
+ *   - prompt the user via their own UI,
+ *   - log execution to their audit trail,
+ *   - apply policy (e.g. block network commands),
+ *   - or refuse outright (throw).
+ *
+ * @example
+ * ```ts
+ * const context: SkillContext = {
+ *   workingDirectory: '/repo',
+ *   executeDynamicContext: async (cmd, cwd) => {
+ *     const approved = await brokerAskUser({ kind: 'skill-cmd', command: cmd, cwd });
+ *     if (!approved) throw new Error('user denied');
+ *     return await brokerExecute(cmd, cwd);
+ *   },
+ * };
+ * ```
+ */
+type SkillDynamicContextExecutor = (command: string, cwd: string) => Promise<string>;
 interface SkillContext {
     workingDirectory: string;
     projectRoot?: string;
-    sessionId: string;
+    /**
+     * Optional. Used to substitute `${CLAUDE_SESSION_ID}` / `${KODAX_SESSION_ID}`
+     * template variables in skill markdown. Tool-invocation callers (e.g. the
+     * `skill` tool) may not have a session bound — in that case the resolver
+     * falls back to an empty replacement so the substitution doesn't leak the
+     * literal `${...}` to the LLM.
+     */
+    sessionId?: string;
     environment?: Record<string, string>;
     messages?: unknown[];
+    /**
+     * v0.7.42 — SDK-embedder hook for `!`cmd`` dynamic-context resolution.
+     * See {@link SkillDynamicContextExecutor} for the trust-boundary rationale.
+     * When present, completely replaces the built-in `execSync`-based path
+     * (whitelist + 5s timeout). When absent, the legacy whitelist path runs.
+     */
+    executeDynamicContext?: SkillDynamicContextExecutor;
+    /**
+     * v0.7.42 — hard-disable `!`cmd`` resolution.
+     * When `true`, encountering a `!`cmd`` token throws
+     * `[Dynamic context disabled by host]` regardless of any hook. Useful for
+     * embedders that want a single-flag kill switch without writing a hook.
+     * `executeDynamicContext` is ignored when this is `true`.
+     */
+    disableDynamicContext?: boolean;
 }
 interface SkillResult {
     success: boolean;
@@ -273,11 +329,23 @@ declare class VariableResolver implements IVariableResolver {
      */
     private resolveEnvVars;
     /**
-     * Replace !`command` with command output (dynamic context)
+     * Replace !`command` with command output (dynamic context).
+     *
+     * Three-tier dispatch (v0.7.42):
+     *   1. `context.disableDynamicContext === true` → throw immediately,
+     *      surfaced to the LLM as `[Error: …]`. Host-level kill switch.
+     *   2. `context.executeDynamicContext` provided → route there. Embedder
+     *      mediates shell execution (broker, audit, deny).
+     *   3. else → legacy built-in path (`isSafeDynamicContextCommand`
+     *      whitelist + `execSync` with 5s timeout).
+     *
+     * The resolver inlines an `[Error: …]` placeholder for any thrown
+     * exception so a single bad token doesn't poison the whole skill load.
      */
     private resolveDynamicContext;
     /**
-     * Execute a dynamic context command
+     * Execute a dynamic context command via the appropriate dispatch tier.
+     * See `resolveDynamicContext` JSDoc for the 3-tier ordering rationale.
      */
     private executeDynamicCommand;
 }
@@ -489,4 +557,4 @@ declare function expandSkillForLLM(skill: Skill, args: string, context: SkillCon
 declare function formatSkillActivationMessage(skillName: string, args: string): string;
 
 export { SkillExecutor, SkillRegistry, VariableResolver, clearPluginSkillPaths, createExecutor, createResolver, discoverSkills, discoverSkillsWithMonorepo, executeSkill, expandSkillForLLM, formatSkillActivationMessage, getDefaultSkillPaths, getNestedSkillPaths, getSkillPathsFlat, getSkillRegistry, initializeSkillRegistry, listPluginSkillPaths, loadFullSkill, loadSkillFileContent, loadSkillMetadata, parseArguments, parseSkillMarkdown, registerPluginSkillPath, resetSkillRegistry, resolveSkillContent, unregisterPluginSkillPath };
-export type { DiscoveryResult, ExecutionMode, ExecutionOptions, ISkillRegistry, IVariableResolver, Skill, SkillArtifact, SkillContext, SkillExpansionResult, SkillFile, SkillFrontmatter, SkillHook, SkillHooks, SkillMetadata, SkillPathsConfig, SkillResult, SkillSource };
+export type { DiscoveryResult, ExecutionMode, ExecutionOptions, ISkillRegistry, IVariableResolver, Skill, SkillArtifact, SkillContext, SkillDynamicContextExecutor, SkillExpansionResult, SkillFile, SkillFrontmatter, SkillHook, SkillHooks, SkillMetadata, SkillPathsConfig, SkillResult, SkillSource };

package/dist/sdk-skills.js

@@ -1,2 +1,2 @@
 // @kodax-ai/kodax — bundled distribution. See docs/ADR.md ADR-022 + ADR-024.
-import{A as w,B as y,C as z,a as o,b as r,c as e,d as f,e as m,f as p,j as t,k as x,l as a,m as b,n as c,o as d,p as g,q as h,r as i,s as j,t as k,u as l,v as n,w as q,x as s,y as u,z as v}from"./chunks/chunk-EQ5DGS2W.js";import"./chunks/chunk-V4WSBIXB.js";export{u as SkillExecutor,l as SkillRegistry,i as VariableResolver,f as clearPluginSkillPaths,v as createExecutor,j as createResolver,c as discoverSkills,g as discoverSkillsWithMonorepo,w as executeSkill,y as expandSkillForLLM,z as formatSkillActivationMessage,m as getDefaultSkillPaths,d as getNestedSkillPaths,p as getSkillPathsFlat,n as getSkillRegistry,q as initializeSkillRegistry,e as listPluginSkillPaths,a as loadFullSkill,b as loadSkillFileContent,x as loadSkillMetadata,h as parseArguments,t as parseSkillMarkdown,o as registerPluginSkillPath,s as resetSkillRegistry,k as resolveSkillContent,r as unregisterPluginSkillPath};
+import{Ab as o,Eb as k,Fb as r,Gb as S,Hb as s,Ib as n,Jb as g,Kb as u,Lb as c,Mb as x,Nb as d,Ob as P,Pb as R,Qb as h,Rb as p,Sb as v,Tb as y,Ub as M,Vb as f,Wb as m,Xb as E,vb as l,wb as e,xb as i,yb as t,zb as a}from"./chunks/chunk-VHKAJDQD.js";import"./chunks/chunk-V4WSBIXB.js";export{y as SkillExecutor,R as SkillRegistry,x as VariableResolver,t as clearPluginSkillPaths,M as createExecutor,d as createResolver,n as discoverSkills,u as discoverSkillsWithMonorepo,f as executeSkill,m as expandSkillForLLM,E as formatSkillActivationMessage,a as getDefaultSkillPaths,g as getNestedSkillPaths,o as getSkillPathsFlat,h as getSkillRegistry,p as initializeSkillRegistry,i as listPluginSkillPaths,S as loadFullSkill,s as loadSkillFileContent,r as loadSkillMetadata,c as parseArguments,k as parseSkillMarkdown,l as registerPluginSkillPath,v as resetSkillRegistry,P as resolveSkillContent,e as unregisterPluginSkillPath};

package/dist/types-chunks/{cost-tracker.d-C4dMlQuV.d.ts → base.d-FUJahC0i.d.ts}

@@ -1,4 +1,4 @@
-import { t as KodaXProviderConfig, o as KodaXMessage, _ as KodaXToolDefinition, I as KodaXReasoningRequest, B as KodaXProviderStreamOptions, N as KodaXStreamResult, p as KodaXModelDescriptor, s as KodaXProviderCapabilityProfile, F as KodaXReasoningCapability, H as KodaXReasoningOverride } from './capability.d-BxNgd1-c.js';
+import { r as KodaXProviderConfig, m as KodaXMessage, X as KodaXToolDefinition, F as KodaXReasoningRequest, z as KodaXProviderStreamOptions, J as KodaXStreamResult, n as KodaXModelDescriptor, q as KodaXProviderCapabilityProfile, C as KodaXReasoningCapability, E as KodaXReasoningOverride } from './types.d-B1uGoVTE.js';
 
 /**
  * Retry-After header parsing — FEATURE_130 (v0.7.36).
@@ -145,8 +145,26 @@ declare abstract class KodaXBaseProvider {
      * Returns undefined when no cap is configured. Consumed by the
      * resilience layer to abort a doomed stream before the server-side
      * kill window fires; routed through `non_streaming_fallback`.
+     *
+     * Cascade (highest to lowest):
+     *   1. Active model descriptor's `streamMaxDurationMs`
+     *   2. Provider config default
+     *   3. undefined (watchdog disabled)
      */
-    getStreamMaxDurationMs(): number | undefined;
+    getStreamMaxDurationMs(model?: string): number | undefined;
+    /**
+     * Resolves whether OpenAI-compat `reasoning_content` should echo back
+     * on replayed assistant messages for the given model. Same cascade as
+     * `getStreamMaxDurationMs`. Defaults to false when neither layer sets it.
+     */
+    getEffectiveReplayReasoningContent(model?: string): boolean;
+    /**
+     * Resolves whether Anthropic-style thinking signatures must verify
+     * strictly (Anthropic proper only). Same cascade as
+     * `getStreamMaxDurationMs`. Defaults to false (lenient) when neither
+     * layer sets it — matches third-party Anthropic-compat behavior.
+     */
+    getEffectiveStrictThinkingSignature(model?: string): boolean;
     abstract stream(messages: KodaXMessage[], tools: KodaXToolDefinition[], system: string, reasoning?: boolean | KodaXReasoningRequest, streamOptions?: KodaXProviderStreamOptions, signal?: AbortSignal): Promise<KodaXStreamResult>;
     supportsNonStreamingFallback(): boolean;
     complete(_messages: KodaXMessage[], _tools: KodaXToolDefinition[], _system: string, _reasoning?: boolean | KodaXReasoningRequest, _streamOptions?: KodaXProviderStreamOptions, _signal?: AbortSignal): Promise<KodaXStreamResult>;
@@ -230,113 +248,5 @@ declare abstract class KodaXBaseProvider {
     protected withRateLimit<T>(fn: () => Promise<T>, signal?: AbortSignal, retries?: number, onRateLimit?: (attempt: number, maxRetries: number, delayMs: number) => void, onRetryAfter?: KodaXOnRetryAfterCallback): Promise<T>;
 }
 
-/**
- * KodaX Cost Rates - Multi-Provider pricing table
- *
- * 成本费率表 - 所有 Provider 的计费标准
- * 支持 11 个内置 Provider 的成本追踪，用户可以覆盖默认费率
- */
-interface CostRate {
-    readonly inputPer1M: number;
-    readonly outputPer1M: number;
-    readonly cachePer1M?: number;
-}
-declare const DEFAULT_COST_RATES: Readonly<Record<string, Readonly<Record<string, CostRate>>>>;
-declare function getCostRate(provider: string, model: string, userOverrides?: Readonly<Record<string, Readonly<Record<string, CostRate>>>>): CostRate | undefined;
-declare function calculateCost(rate: CostRate, inputTokens: number, outputTokens: number, cacheTokens?: number): number;
-
-/**
- * KodaX Cost Tracker - Immutable session cost tracking
- *
- * 成本追踪器 - 不可变的会话成本追踪
- * 使用 Immutable 模式，每次操作都返回新对象而不修改原有对象
- */
-
-interface TokenUsageRecord {
-    readonly timestamp: number;
-    readonly provider: string;
-    readonly model: string;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly cacheReadTokens: number;
-    readonly cacheWriteTokens: number;
-    readonly cost: number;
-    readonly role?: string;
-}
-interface ProviderCostSummary {
-    readonly cost: number;
-    readonly calls: number;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-}
-/**
- * FEATURE_130 (v0.7.36) — per-retry record. Captures the wait the
- * provider asked us to take so `/cost` can report "X retries, Ys total
- * wait" alongside the token cost. Lives in the same tracker as token
- * records to keep one source of truth for the session.
- */
-interface RetryRecord {
-    readonly timestamp: number;
-    readonly provider: string;
-    readonly waitMs: number;
-    readonly reason: 'rate-limit' | 'overloaded';
-    readonly source: 'retry-after-seconds' | 'retry-after-date' | 'retry-after-ms' | 'exponential-backoff';
-}
-interface SessionCostSummary {
-    readonly totalCost: number;
-    readonly totalInputTokens: number;
-    readonly totalOutputTokens: number;
-    readonly totalCacheTokens: number;
-    /** FEATURE_116 (v0.7.37): cumulative cache-read input tokens across the
-     * session. Splits `totalCacheTokens` into the read half so the hit rate
-     * (`cacheHitRate = totalCacheReadTokens / totalCacheTokens`) is
-     * derivable for `/cost` reporting. */
-    readonly totalCacheReadTokens: number;
-    /** FEATURE_116 (v0.7.37): cumulative cache-write (creation) input tokens. */
-    readonly totalCacheWriteTokens: number;
-    /** FEATURE_116 (v0.7.37): cache-read share of all cache tokens this
-     * session, in [0, 1]. Computed as `totalCacheReadTokens /
-     * (totalCacheReadTokens + totalCacheWriteTokens)`. Returns 0 when no
-     * cache activity has been recorded — a session with zero cache
-     * activity is not "0% hit rate", just untracked. */
-    readonly cacheHitRate: number;
-    readonly callCount: number;
-    /** FEATURE_130: total retries triggered across the session. */
-    readonly retryCount: number;
-    /** FEATURE_130: cumulative milliseconds spent in retry-after sleeps. */
-    readonly retryWaitMs: number;
-    readonly byProvider: Readonly<Record<string, ProviderCostSummary>>;
-    readonly byRole: Readonly<Record<string, ProviderCostSummary>>;
-}
-interface CostTracker {
-    readonly records: readonly TokenUsageRecord[];
-    /** FEATURE_130 (v0.7.36): retry-wait records, append-only and immutable. */
-    readonly retries: readonly RetryRecord[];
-}
-declare function createCostTracker(): CostTracker;
-/**
- * FEATURE_130 (v0.7.36): record a retry-after wait. The InkREPL spinner
- * (or any other consumer of `KodaXEvents.onRetryAfter`) calls this so
- * `/cost` can surface accurate session-wide retry telemetry.
- */
-declare function recordRetry(tracker: CostTracker, entry: {
-    readonly provider: string;
-    readonly waitMs: number;
-    readonly reason: 'rate-limit' | 'overloaded';
-    readonly source: 'retry-after-seconds' | 'retry-after-date' | 'retry-after-ms' | 'exponential-backoff';
-}): CostTracker;
-declare function recordUsage(tracker: CostTracker, entry: {
-    readonly provider: string;
-    readonly model: string;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly cacheReadTokens?: number;
-    readonly cacheWriteTokens?: number;
-    readonly role?: string;
-}, userCostOverrides?: Readonly<Record<string, Readonly<Record<string, CostRate>>>>): CostTracker;
-declare function getSummary(tracker: CostTracker): SessionCostSummary;
-declare function formatCost(usd: number): string;
-declare function formatCostReport(summary: SessionCostSummary): string;
-
-export { DEFAULT_COST_RATES as D, KodaXBaseProvider as K, calculateCost as g, createCostTracker as h, extractHeadersFromError as i, formatCost as j, formatCostReport as k, getCostRate as l, getSummary as m, recordUsage as n, parseRetryAfter as p, recordRetry as r };
-export type { CostRate as C, ParseRetryAfterOptions as P, RetryAfterResult as R, SessionCostSummary as S, TokenUsageRecord as T, CostTracker as a, KodaXOnRetryAfterCallback as b, KodaXRetryAfterEvent as c, ProviderCostSummary as d, RetryAfterSource as e, RetryRecord as f };
+export { KodaXBaseProvider as K, extractHeadersFromError as e, parseRetryAfter as p };
+export type { ParseRetryAfterOptions as P, RetryAfterResult as R, KodaXOnRetryAfterCallback as a, KodaXRetryAfterEvent as b, RetryAfterSource as c };