@vibeiao/sdk 0.1.29 → 0.1.30

package/dist/chunk-PVCW4MAY.js

@@ -0,0 +1,99 @@
+// src/durabilityProxy.ts
+var withTimeout = async (fetcher, input, init, timeoutMs) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetcher(input, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var readJson = async (response) => {
+  const text = await response.text();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+};
+var createDurabilityProxyClient = (options) => {
+  const fetcher = options.fetcher || fetch;
+  const timeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Math.max(500, Number(options.timeoutMs)) : 8e3;
+  const base = String(options.baseUrl || "").replace(/\/+$/, "");
+  const agentId = String(options.agentId || "").trim();
+  const agentToken = String(options.agentToken || "").trim();
+  if (!base) throw new Error("durability_proxy_base_missing");
+  if (!agentId) throw new Error("durability_proxy_agent_id_missing");
+  if (!agentToken) throw new Error("durability_proxy_agent_token_missing");
+  const headers = {
+    "content-type": "application/json",
+    "x-agent-id": agentId,
+    "x-agent-token": agentToken
+  };
+  return {
+    async writeCheckpoint(payloadJson, opts = {}) {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            payloadJson,
+            sha256: opts.sha256,
+            contentType: opts.contentType,
+            metadata: opts.metadata
+          })
+        },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_checkpoint_write_failed:${detail}`);
+      }
+      return body;
+    },
+    async latestCheckpoint() {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints/latest`,
+        { method: "GET", headers: { "x-agent-id": agentId, "x-agent-token": agentToken } },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_checkpoint_latest_failed:${detail}`);
+      }
+      return body;
+    },
+    async writeRestoreDrill(ok, opts = {}) {
+      const response = await withTimeout(
+        fetcher,
+        `${base}/v1/checkpoints/restore-drill`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            checkpointId: opts.checkpointId,
+            ok,
+            details: opts.details
+          })
+        },
+        timeoutMs
+      );
+      const body = await readJson(response);
+      if (!response.ok) {
+        const detail = body?.error || `http_${response.status}`;
+        throw new Error(`durability_restore_drill_write_failed:${detail}`);
+      }
+      return body;
+    }
+  };
+};
+
+export {
+  createDurabilityProxyClient
+};

package/dist/chunk-RNPCT2MS.js

@@ -0,0 +1,157 @@
+// src/treasuryGuardian.ts
+var createTreasuryPolicy = (partial) => {
+  const base = {
+    version: 1,
+    budgets: {
+      dailyUsd: 20,
+      monthlyUsd: 300,
+      perTopupUsd: 5,
+      maxTopupsPerDay: 3
+    },
+    providers: {
+      allow: ["openrouter"],
+      modelsAllow: []
+    },
+    thresholds: {
+      warnCredits: { openrouter: 5 },
+      minCredits: { openrouter: 1 }
+    },
+    automation: {
+      autoApproveUnderUsd: 3,
+      cooldownMinutes: 30,
+      requireHumanAboveUsd: 3
+    },
+    safety: {
+      maxErrorRate5m: 0.35,
+      maxSpendSpikeMultiplier: 3,
+      onViolation: "safe_mode"
+    }
+  };
+  return {
+    ...base,
+    ...partial,
+    budgets: { ...base.budgets, ...partial?.budgets || {} },
+    providers: { ...base.providers, ...partial?.providers || {} },
+    thresholds: { ...base.thresholds, ...partial?.thresholds || {} },
+    automation: { ...base.automation, ...partial?.automation || {} },
+    safety: { ...base.safety, ...partial?.safety || {} }
+  };
+};
+var isFiniteNumber = (n) => typeof n === "number" && Number.isFinite(n);
+var validateTreasuryPolicy = (policy) => {
+  const errors = [];
+  if (!policy || policy.version !== 1) errors.push("policy_version_invalid");
+  const b = policy?.budgets;
+  if (!b) errors.push("budgets_missing");
+  if (!isFiniteNumber(b?.dailyUsd) || (b?.dailyUsd ?? 0) <= 0) errors.push("budget_daily_invalid");
+  if (b?.monthlyUsd !== void 0 && (!isFiniteNumber(b.monthlyUsd) || b.monthlyUsd <= 0)) errors.push("budget_monthly_invalid");
+  if (!isFiniteNumber(b?.perTopupUsd) || (b?.perTopupUsd ?? 0) <= 0) errors.push("budget_per_topup_invalid");
+  if (!Number.isInteger(b?.maxTopupsPerDay) || (b?.maxTopupsPerDay ?? 0) < 0) errors.push("budget_max_topups_invalid");
+  const allow = policy?.providers?.allow;
+  if (!Array.isArray(allow) || allow.length === 0) errors.push("providers_allow_missing");
+  const warn = policy?.thresholds?.warnCredits;
+  const min = policy?.thresholds?.minCredits;
+  if (!warn || typeof warn !== "object") errors.push("thresholds_warn_missing");
+  if (!min || typeof min !== "object") errors.push("thresholds_min_missing");
+  const a = policy?.automation;
+  if (!isFiniteNumber(a?.autoApproveUnderUsd) || (a?.autoApproveUnderUsd ?? 0) < 0) errors.push("automation_auto_approve_invalid");
+  if (!isFiniteNumber(a?.requireHumanAboveUsd) || (a?.requireHumanAboveUsd ?? 0) < 0) errors.push("automation_human_threshold_invalid");
+  if (!Number.isInteger(a?.cooldownMinutes) || (a?.cooldownMinutes ?? 0) < 0) errors.push("automation_cooldown_invalid");
+  const s = policy?.safety;
+  if (!s || !["safe_mode", "pause", "stop"].includes(s.onViolation)) errors.push("safety_on_violation_invalid");
+  return { ok: errors.length === 0, errors };
+};
+var normalizeProvider = (value) => String(value || "").trim().toLowerCase();
+var evaluateTopupRequest = (request, state, policy) => {
+  const reasonCodes = [];
+  const provider = normalizeProvider(request.provider);
+  const v = validateTreasuryPolicy(policy);
+  if (!v.ok) {
+    return { action: "deny", reasonCodes: ["policy_invalid", ...v.errors] };
+  }
+  if (!policy.providers.allow.map(normalizeProvider).includes(provider)) {
+    return { action: "deny", reasonCodes: ["provider_not_allowed"] };
+  }
+  if (!isFiniteNumber(request.amountUsd) || request.amountUsd <= 0) {
+    return { action: "deny", reasonCodes: ["amount_invalid"] };
+  }
+  const perTopup = policy.budgets.perTopupUsd;
+  if (request.amountUsd > perTopup) {
+    reasonCodes.push("amount_exceeds_per_topup_cap");
+  }
+  const now = request.requestedAt;
+  const cooldownSec = policy.automation.cooldownMinutes * 60;
+  if (state.lastTopupAt && cooldownSec > 0) {
+    const elapsed = Math.max(0, (now - state.lastTopupAt) / 1e3);
+    if (elapsed < cooldownSec) {
+      return {
+        action: "deny",
+        reasonCodes: ["cooldown_active"],
+        cooldownRemainingSec: Math.ceil(cooldownSec - elapsed)
+      };
+    }
+  }
+  if (state.topupsToday >= policy.budgets.maxTopupsPerDay) {
+    return { action: "deny", reasonCodes: ["daily_topup_cap_reached"] };
+  }
+  if (policy.safety.maxErrorRate5m !== void 0 && state.errorRate5m !== void 0) {
+    if (state.errorRate5m > policy.safety.maxErrorRate5m) {
+      return { action: "require_human", reasonCodes: ["high_error_rate_requires_human"] };
+    }
+  }
+  if (policy.safety.maxSpendSpikeMultiplier !== void 0 && state.spendSpikeMultiplier !== void 0) {
+    if (state.spendSpikeMultiplier > policy.safety.maxSpendSpikeMultiplier) {
+      return { action: "require_human", reasonCodes: ["spend_spike_requires_human"] };
+    }
+  }
+  const minCredits = policy.thresholds.minCredits[provider];
+  const warnCredits = policy.thresholds.warnCredits[provider];
+  const credits = state.providerCredits[provider];
+  if (typeof minCredits === "number" && typeof credits === "number" && credits > minCredits) {
+    reasonCodes.push("credits_above_min");
+  }
+  if (typeof warnCredits === "number" && typeof credits === "number" && credits > warnCredits) {
+    reasonCodes.push("credits_above_warn");
+  }
+  if (request.amountUsd > policy.automation.requireHumanAboveUsd) {
+    return { action: "require_human", reasonCodes: ["amount_above_human_threshold", ...reasonCodes] };
+  }
+  if (request.amountUsd <= policy.automation.autoApproveUnderUsd && request.amountUsd <= perTopup) {
+    return {
+      action: "approve",
+      reasonCodes: ["auto_approved", ...reasonCodes],
+      approvedAmountUsd: request.amountUsd
+    };
+  }
+  return { action: "require_human", reasonCodes: ["manual_zone", ...reasonCodes] };
+};
+var buildTreasuryLedgerEvent = (event) => ({
+  ...event,
+  ts: Number.isFinite(event.ts) ? event.ts : Date.now()
+});
+var treasuryStateFromSnapshot = (snapshot) => {
+  const providerCredits = {};
+  const apiCredits = snapshot?.apiCredits;
+  if (apiCredits && typeof apiCredits === "object") {
+    for (const [key, value] of Object.entries(apiCredits)) {
+      const num = typeof value === "number" ? value : Number(value);
+      if (Number.isFinite(num)) providerCredits[normalizeProvider(key)] = num;
+    }
+  }
+  if (snapshot?.openRouterCredits !== void 0) {
+    const num = Number(snapshot.openRouterCredits);
+    if (Number.isFinite(num)) providerCredits.openrouter = num;
+  }
+  return {
+    providerCredits,
+    topupsToday: 0
+  };
+};
+
+export {
+  createTreasuryPolicy,
+  validateTreasuryPolicy,
+  evaluateTopupRequest,
+  buildTreasuryLedgerEvent,
+  treasuryStateFromSnapshot
+};

package/dist/compoundingMemory.d.ts

@@ -0,0 +1,125 @@
+declare const COMPOUNDING_MEMORY_VERSION = 1;
+type CompoundingMemoryOptions = {
+    /** Workspace root where top-level files are stored. */
+    root?: string;
+    /** Timezone used for YYYY-MM-DD daily ledgers. */
+    timeZone?: string;
+    /** Override current time (tests). */
+    now?: Date;
+    /** Whether to initialize memory/graph scaffold. Default true. */
+    includeGraph?: boolean;
+    /** Whether to initialize projects/ dossier scaffold. Default true. */
+    includeProjects?: boolean;
+    /** Append one upgrade marker to today's daily log. Default true. */
+    appendUpgradeNote?: boolean;
+};
+type CompoundingMemoryUpgradeResult = {
+    root: string;
+    memoryDir: string;
+    graphDir: string | null;
+    projectsDir: string | null;
+    dateKey: string;
+    dailyLedgerPath: string;
+    created: string[];
+    touched: string[];
+    existed: string[];
+    changed: boolean;
+    version: number;
+};
+declare const readCompoundingMemoryVersion: (root?: string) => Promise<number>;
+declare const upgradeCompoundingMemorySystem: (options?: CompoundingMemoryOptions) => Promise<CompoundingMemoryUpgradeResult>;
+type WorkingStateDisciplineOptions = {
+    root?: string;
+    timeZone?: string;
+    now?: Date;
+    maxLines?: number;
+    maxChars?: number;
+    /** Max overflow characters moved into ledger note. */
+    maxOverflowChars?: number;
+};
+type WorkingStateDisciplineResult = {
+    filePath: string;
+    ledgerPath: string;
+    lineCount: number;
+    charCount: number;
+    maxLines: number;
+    maxChars: number;
+    bounded: boolean;
+    trimmed: boolean;
+    movedChars: number;
+};
+type RecallSubstrateCheckOptions = {
+    root?: string;
+};
+type RecallSubstrateCheckResult = {
+    ok: boolean;
+    goldenQueryCount: number;
+    nodeCount: number;
+    edgeCount: number;
+    issues: string[];
+};
+type CompoundingMemoryBackupOptions = {
+    root?: string;
+    backupDir?: string;
+    retention?: number;
+    now?: Date;
+};
+type CompoundingMemoryBackupResult = {
+    backupPath: string;
+    createdAt: string;
+    fileCount: number;
+    sizeBytes: number;
+    sha256: string;
+};
+type CompoundingMemoryRestoreDrillOptions = {
+    root?: string;
+    backupDir?: string;
+    retention?: number;
+    now?: Date;
+    /** Keep restored drill directory for inspection. Default false (auto-clean). */
+    keepRestoreRoot?: boolean;
+};
+type CompoundingMemoryRestoreDrillResult = {
+    ok: boolean;
+    backup: CompoundingMemoryBackupResult;
+    restoredFiles: number;
+    checkedFiles: string[];
+    restoreRoot: string;
+};
+type CompoundingMemoryRequiredSetOptions = {
+    root?: string;
+    timeZone?: string;
+    now?: Date;
+    workingStateMaxLines?: number;
+    workingStateMaxChars?: number;
+    runBackupRestoreDrill?: boolean;
+    backupDir?: string;
+    backupRetention?: number;
+};
+type CompoundingMemoryRequiredSetResult = {
+    ok: boolean;
+    root: string;
+    upgrade: CompoundingMemoryUpgradeResult;
+    workingState: WorkingStateDisciplineResult;
+    recall: RecallSubstrateCheckResult;
+    restoreDrill: CompoundingMemoryRestoreDrillResult | null;
+    checkedAt: string;
+};
+type CompoundingMemoryRequiredSetSchedulerOptions = CompoundingMemoryRequiredSetOptions & {
+    intervalMs?: number;
+    onSuccess?: (result: CompoundingMemoryRequiredSetResult) => void | Promise<void>;
+    onError?: (error: Error) => void | Promise<void>;
+};
+declare const enforceWorkingStateDiscipline: (options?: WorkingStateDisciplineOptions) => Promise<WorkingStateDisciplineResult>;
+declare const checkRecallSubstrate: (options?: RecallSubstrateCheckOptions) => Promise<RecallSubstrateCheckResult>;
+declare const createCompoundingMemoryBackup: (options?: CompoundingMemoryBackupOptions) => Promise<CompoundingMemoryBackupResult>;
+declare const runCompoundingMemoryRestoreDrill: (options?: CompoundingMemoryRestoreDrillOptions) => Promise<CompoundingMemoryRestoreDrillResult>;
+declare const runCompoundingMemoryRequiredSet: (options?: CompoundingMemoryRequiredSetOptions) => Promise<CompoundingMemoryRequiredSetResult>;
+declare const createCompoundingMemoryRequiredSetScheduler: (options?: CompoundingMemoryRequiredSetSchedulerOptions) => {
+    start: () => Promise<void>;
+    stop: () => void;
+    runOnce: () => Promise<CompoundingMemoryRequiredSetResult>;
+};
+declare const ensureCompoundingMemorySystem: (options?: CompoundingMemoryOptions) => Promise<CompoundingMemoryUpgradeResult>;
+
+export { COMPOUNDING_MEMORY_VERSION, type CompoundingMemoryBackupOptions, type CompoundingMemoryBackupResult, type CompoundingMemoryOptions, type CompoundingMemoryRequiredSetOptions, type CompoundingMemoryRequiredSetResult, type CompoundingMemoryRequiredSetSchedulerOptions, type CompoundingMemoryRestoreDrillOptions, type CompoundingMemoryRestoreDrillResult, type CompoundingMemoryUpgradeResult, type RecallSubstrateCheckOptions, type RecallSubstrateCheckResult, type WorkingStateDisciplineOptions, type WorkingStateDisciplineResult, checkRecallSubstrate, createCompoundingMemoryBackup, createCompoundingMemoryRequiredSetScheduler, enforceWorkingStateDiscipline, ensureCompoundingMemorySystem, readCompoundingMemoryVersion, runCompoundingMemoryRequiredSet, runCompoundingMemoryRestoreDrill, upgradeCompoundingMemorySystem };

package/dist/compoundingMemory.js

@@ -0,0 +1,24 @@
+import {
+  COMPOUNDING_MEMORY_VERSION,
+  checkRecallSubstrate,
+  createCompoundingMemoryBackup,
+  createCompoundingMemoryRequiredSetScheduler,
+  enforceWorkingStateDiscipline,
+  ensureCompoundingMemorySystem,
+  readCompoundingMemoryVersion,
+  runCompoundingMemoryRequiredSet,
+  runCompoundingMemoryRestoreDrill,
+  upgradeCompoundingMemorySystem
+} from "./chunk-JJNRDU7F.js";
+export {
+  COMPOUNDING_MEMORY_VERSION,
+  checkRecallSubstrate,
+  createCompoundingMemoryBackup,
+  createCompoundingMemoryRequiredSetScheduler,
+  enforceWorkingStateDiscipline,
+  ensureCompoundingMemorySystem,
+  readCompoundingMemoryVersion,
+  runCompoundingMemoryRequiredSet,
+  runCompoundingMemoryRestoreDrill,
+  upgradeCompoundingMemorySystem
+};