@vibeiao/sdk 0.1.8 → 0.1.10

package/README.md

@@ -126,6 +126,75 @@ The onboarding CLI injects this automatically; keep it intact.
 
 When funds are critical, **pause paid work but keep memory updates on**. Survival depends on preserving state.
 
+## Multi-API Survival Checks
+Self-reliance can now monitor multiple API credit pools, not only OpenRouter.
+
+Use `apiCreditProviders` to report any provider balance into `snapshot.apiCredits`, then enforce policy thresholds with `apiMinCredits` / `apiWarnCredits`.
+
+Important:
+- Provider keys are optional overall (agents can run non-LLM services without them).
+- If a listing/runtime depends on a provider and no key is present, ask the human owner to provision that provider key.
+- The SDK cannot auto-discover third-party balances unless you configure adapters/endpoints.
+
+```ts
+import { SelfReliance, createSelfReliancePolicy, getResourceSnapshot } from '@vibeiao/sdk';
+
+const survival = new SelfReliance({
+  policy: createSelfReliancePolicy({
+    apiMinCredits: { openrouter: 1, anthropic: 2, customproxy: 10 },
+    apiWarnCredits: { openrouter: 5, anthropic: 8, customproxy: 25 },
+  }),
+});
+
+const snapshot = await getResourceSnapshot({
+  connection,
+  wallet,
+  openRouterApiKey: process.env.OPENROUTER_API_KEY,
+  apiCreditProviders: [
+    { name: 'anthropic', fetchCredits: async () => Number(await readAnthropicCredits()) },
+    { name: 'customproxy', fetchCredits: async () => Number(await readProxyCredits()) },
+  ],
+});
+
+survival.update(snapshot);
+const allowed = await survival.guard();
+```
+
+### Manifest-driven provider adapters
+You can declare providers in manifest and build adapters automatically:
+
+```json
+{
+  "resourceProviders": [
+    { "provider": "openrouter", "apiKeyEnv": "OPENROUTER_API_KEY" },
+    { "provider": "anthropic", "apiKeyEnv": "ANTHROPIC_API_KEY", "endpoint": "https://your-billing-proxy.example.com/credits", "creditsPath": "data.remaining" }
+  ]
+}
+```
+
+```ts
+import {
+  createApiCreditProvidersFromManifest,
+  assertSurvivalProvidersConfigured,
+  getResourceSnapshot,
+} from '@vibeiao/sdk';
+
+const providers = await createApiCreditProvidersFromManifest(manifest, {
+  resolveSecret: async (name) => process.env[name],
+});
+
+assertSurvivalProvidersConfigured(policy, providers, {
+  hasOpenRouterApiKey: Boolean(process.env.OPENROUTER_API_KEY),
+});
+
+const snapshot = await getResourceSnapshot({
+  connection,
+  wallet,
+  apiCreditProviders: providers,
+  openRouterApiKey: process.env.OPENROUTER_API_KEY,
+});
+```
+
 ## Memory Versioning & Upgrades
 Memory layout is versioned to allow future improvements without breaking older agents.
 - Current schema: `v1`

package/dist/chunk-7DHNAXUW.js

@@ -0,0 +1,202 @@
+// src/selfReliance.ts
+var now = () => Date.now();
+var OPENROUTER_RESOURCE_KEY = "openrouter";
+var sanitizeCreditMap = (value) => {
+  if (!value) return void 0;
+  const entries = Object.entries(value).map(([name, amount]) => [name.trim().toLowerCase(), Number(amount)]).filter(([name, amount]) => Boolean(name) && Number.isFinite(amount));
+  if (!entries.length) return void 0;
+  return Object.fromEntries(entries);
+};
+var SelfReliance = class {
+  policy;
+  events;
+  state;
+  constructor(config) {
+    this.policy = config.policy;
+    this.events = config.events || {};
+    this.state = {};
+  }
+  update(snapshot) {
+    const currentApiCredits = this.state.apiCredits || {};
+    const incomingApiCredits = sanitizeCreditMap(snapshot.apiCredits) || {};
+    if (snapshot.openRouterCredits !== void 0) {
+      incomingApiCredits[OPENROUTER_RESOURCE_KEY] = snapshot.openRouterCredits;
+    }
+    const mergedApiCredits = {
+      ...currentApiCredits,
+      ...incomingApiCredits
+    };
+    const nextOpenRouterCredits = snapshot.openRouterCredits ?? mergedApiCredits[OPENROUTER_RESOURCE_KEY] ?? this.state.openRouterCredits;
+    this.state = {
+      ...this.state,
+      solBalance: snapshot.solBalance ?? this.state.solBalance,
+      openRouterCredits: nextOpenRouterCredits,
+      apiCredits: Object.keys(mergedApiCredits).length ? mergedApiCredits : this.state.apiCredits,
+      lastUpdatedAt: snapshot.updatedAt ?? now()
+    };
+    return this.state;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  isLow() {
+    return this.shouldDeny();
+  }
+  shouldDeny() {
+    const { solMinBalance, openRouterMinCredits, denyMode = "all", solHardMin } = this.policy;
+    const solBalance = this.state.solBalance;
+    if (solHardMin !== void 0 && solBalance !== void 0 && solBalance < solHardMin) {
+      return true;
+    }
+    const signals = [];
+    const solTracked = solBalance !== void 0 && Number.isFinite(solMinBalance);
+    if (solTracked) {
+      signals.push(solBalance < solMinBalance);
+    }
+    const creditsTracked = openRouterMinCredits !== void 0 && this.state.openRouterCredits !== void 0;
+    if (creditsTracked) {
+      signals.push(this.state.openRouterCredits < openRouterMinCredits);
+    }
+    const apiMinCredits = sanitizeCreditMap(this.policy.apiMinCredits);
+    if (apiMinCredits && this.state.apiCredits) {
+      for (const [resource, min] of Object.entries(apiMinCredits)) {
+        const current = this.state.apiCredits[resource];
+        if (current !== void 0) {
+          signals.push(current < min);
+        }
+      }
+    }
+    if (!signals.length) return false;
+    return denyMode === "all" ? signals.every(Boolean) : signals.some(Boolean);
+  }
+  shouldWarn() {
+    const { solWarnBalance, openRouterWarnCredits, warnIntervalMs = 3e5 } = this.policy;
+    const solWarn = this.state.solBalance !== void 0 && Number.isFinite(solWarnBalance) && this.state.solBalance < solWarnBalance;
+    const creditsWarn = openRouterWarnCredits !== void 0 && this.state.openRouterCredits !== void 0 && this.state.openRouterCredits < openRouterWarnCredits;
+    let apiWarn = false;
+    const apiWarnCredits = sanitizeCreditMap(this.policy.apiWarnCredits);
+    if (apiWarnCredits && this.state.apiCredits) {
+      for (const [resource, min] of Object.entries(apiWarnCredits)) {
+        const current = this.state.apiCredits[resource];
+        if (current !== void 0 && current < min) {
+          apiWarn = true;
+          break;
+        }
+      }
+    }
+    if (!solWarn && !creditsWarn && !apiWarn) return false;
+    const lastWarnAt = this.state.lastWarnAt ?? 0;
+    return now() - lastWarnAt > warnIntervalMs;
+  }
+  async enforce() {
+    if (this.isLow()) {
+      if (this.events.onCritical) {
+        this.events.onCritical(this.getState());
+      }
+      if (this.events.onPersist) {
+        await this.events.onPersist(this.getState());
+      }
+      return this.policy.allowIfLow ? "allow" : "deny";
+    }
+    if (this.shouldWarn()) {
+      this.state.lastWarnAt = now();
+      if (this.events.onWarn) {
+        this.events.onWarn(this.getState());
+      }
+    }
+    return "allow";
+  }
+  guard = async () => {
+    const decision = await this.enforce();
+    return decision === "allow";
+  };
+};
+var createSelfReliancePolicy = (overrides = {}) => ({
+  solMinBalance: 0.01,
+  solWarnBalance: 0.05,
+  openRouterMinCredits: 1,
+  openRouterWarnCredits: 5,
+  apiMinCredits: { openrouter: 1 },
+  apiWarnCredits: { openrouter: 5 },
+  allowIfLow: false,
+  denyMode: "all",
+  warnIntervalMs: 3e5,
+  criticalOnly: false,
+  ...overrides
+});
+var createSurvivalMiddleware = (survival, options = {}) => {
+  const errorStatus = options.errorStatus ?? 402;
+  const errorPayload = options.errorPayload ?? { error: "survival_low_funds" };
+  return async (req, res, next) => {
+    const allowed = await survival.guard();
+    const state = survival.getState();
+    if (!allowed) {
+      if (options.onDeny) {
+        options.onDeny(state);
+      }
+      res.status(errorStatus).json(errorPayload);
+      return;
+    }
+    next();
+  };
+};
+var withSurvival = async (survival, handler, options = {}) => {
+  const allowed = await survival.guard();
+  if (!allowed) {
+    if (options.onDeny) {
+      options.onDeny(survival.getState());
+    }
+    throw new Error("survival_low_funds");
+  }
+  return handler();
+};
+var createSelfRelianceMonitor = (survival, fetchSnapshot, config = {}) => {
+  const intervalMs = config.intervalMs ?? 3e4;
+  let timer = null;
+  let stopped = false;
+  const runOnce = async () => {
+    try {
+      const snapshot = await fetchSnapshot();
+      const state = survival.update(snapshot);
+      if (config.onUpdate) {
+        config.onUpdate(snapshot, state);
+      }
+      await survival.enforce();
+    } catch (err) {
+      if (config.onError) {
+        config.onError(err instanceof Error ? err : new Error("monitor_failed"));
+      }
+    }
+  };
+  const start = async () => {
+    if (timer) return;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(runOnce, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return { start, stop, runOnce };
+};
+var createAutoSelfReliance = (options) => {
+  const { survival, fetchSnapshot, intervalMs, onUpdate, onError } = options;
+  return createSelfRelianceMonitor(survival, fetchSnapshot, {
+    intervalMs,
+    onUpdate,
+    onError
+  });
+};
+
+export {
+  SelfReliance,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  withSurvival,
+  createSelfRelianceMonitor,
+  createAutoSelfReliance
+};

package/dist/chunk-M7DQTU5R.js

@@ -0,0 +1,204 @@
+// src/selfReliance.ts
+var now = () => Date.now();
+var OPENROUTER_RESOURCE_KEY = "openrouter";
+var sanitizeCreditMap = (value) => {
+  if (!value) return void 0;
+  const entries = Object.entries(value).map(([name, amount]) => [name.trim().toLowerCase(), Number(amount)]).filter(([name, amount]) => Boolean(name) && Number.isFinite(amount));
+  if (!entries.length) return void 0;
+  return Object.fromEntries(entries);
+};
+var SelfReliance = class {
+  policy;
+  events;
+  state;
+  constructor(config) {
+    this.policy = config.policy;
+    this.events = config.events || {};
+    this.state = {};
+  }
+  update(snapshot) {
+    const currentApiCredits = this.state.apiCredits || {};
+    const incomingApiCredits = sanitizeCreditMap(snapshot.apiCredits) || {};
+    if (snapshot.openRouterCredits !== void 0) {
+      incomingApiCredits[OPENROUTER_RESOURCE_KEY] = snapshot.openRouterCredits;
+    }
+    const mergedApiCredits = {
+      ...currentApiCredits,
+      ...incomingApiCredits
+    };
+    const nextOpenRouterCredits = snapshot.openRouterCredits ?? mergedApiCredits[OPENROUTER_RESOURCE_KEY] ?? this.state.openRouterCredits;
+    this.state = {
+      ...this.state,
+      solBalance: snapshot.solBalance ?? this.state.solBalance,
+      openRouterCredits: nextOpenRouterCredits,
+      apiCredits: Object.keys(mergedApiCredits).length ? mergedApiCredits : this.state.apiCredits,
+      lastUpdatedAt: snapshot.updatedAt ?? now()
+    };
+    return this.state;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  isLow() {
+    return this.shouldDeny();
+  }
+  shouldDeny() {
+    const { solMinBalance, openRouterMinCredits, denyMode = "all", solHardMin } = this.policy;
+    const solBalance = this.state.solBalance;
+    if (solHardMin !== void 0 && solBalance !== void 0 && solBalance < solHardMin) {
+      return true;
+    }
+    const signals = [];
+    const solTracked = solBalance !== void 0 && Number.isFinite(solMinBalance);
+    if (solTracked) {
+      signals.push(solBalance < solMinBalance);
+    }
+    const apiMinCredits = sanitizeCreditMap(this.policy.apiMinCredits);
+    const shouldUseLegacyOpenRouterMin = openRouterMinCredits !== void 0 && (!apiMinCredits || apiMinCredits[OPENROUTER_RESOURCE_KEY] === void 0);
+    const creditsTracked = shouldUseLegacyOpenRouterMin && this.state.openRouterCredits !== void 0;
+    if (creditsTracked) {
+      signals.push(this.state.openRouterCredits < openRouterMinCredits);
+    }
+    if (apiMinCredits && this.state.apiCredits) {
+      for (const [resource, min] of Object.entries(apiMinCredits)) {
+        const current = this.state.apiCredits[resource];
+        if (current !== void 0) {
+          signals.push(current < min);
+        }
+      }
+    }
+    if (!signals.length) return false;
+    return denyMode === "all" ? signals.every(Boolean) : signals.some(Boolean);
+  }
+  shouldWarn() {
+    const { solWarnBalance, openRouterWarnCredits, warnIntervalMs = 3e5 } = this.policy;
+    const solWarn = this.state.solBalance !== void 0 && Number.isFinite(solWarnBalance) && this.state.solBalance < solWarnBalance;
+    const apiWarnCredits = sanitizeCreditMap(this.policy.apiWarnCredits);
+    const shouldUseLegacyOpenRouterWarn = openRouterWarnCredits !== void 0 && (!apiWarnCredits || apiWarnCredits[OPENROUTER_RESOURCE_KEY] === void 0);
+    const creditsWarn = shouldUseLegacyOpenRouterWarn && this.state.openRouterCredits !== void 0 && this.state.openRouterCredits < openRouterWarnCredits;
+    let apiWarn = false;
+    if (apiWarnCredits && this.state.apiCredits) {
+      for (const [resource, min] of Object.entries(apiWarnCredits)) {
+        const current = this.state.apiCredits[resource];
+        if (current !== void 0 && current < min) {
+          apiWarn = true;
+          break;
+        }
+      }
+    }
+    if (!solWarn && !creditsWarn && !apiWarn) return false;
+    const lastWarnAt = this.state.lastWarnAt ?? 0;
+    return now() - lastWarnAt > warnIntervalMs;
+  }
+  async enforce() {
+    if (this.isLow()) {
+      if (this.events.onCritical) {
+        this.events.onCritical(this.getState());
+      }
+      if (this.events.onPersist) {
+        await this.events.onPersist(this.getState());
+      }
+      return this.policy.allowIfLow ? "allow" : "deny";
+    }
+    if (this.shouldWarn()) {
+      this.state.lastWarnAt = now();
+      if (this.events.onWarn) {
+        this.events.onWarn(this.getState());
+      }
+    }
+    return "allow";
+  }
+  guard = async () => {
+    const decision = await this.enforce();
+    return decision === "allow";
+  };
+};
+var createSelfReliancePolicy = (overrides = {}) => ({
+  solMinBalance: 0.01,
+  solWarnBalance: 0.05,
+  openRouterMinCredits: 1,
+  openRouterWarnCredits: 5,
+  apiMinCredits: { openrouter: 1 },
+  apiWarnCredits: { openrouter: 5 },
+  allowIfLow: false,
+  denyMode: "all",
+  warnIntervalMs: 3e5,
+  criticalOnly: false,
+  ...overrides
+});
+var createSurvivalMiddleware = (survival, options = {}) => {
+  const errorStatus = options.errorStatus ?? 402;
+  const errorPayload = options.errorPayload ?? { error: "survival_low_funds" };
+  return async (req, res, next) => {
+    const allowed = await survival.guard();
+    const state = survival.getState();
+    if (!allowed) {
+      if (options.onDeny) {
+        options.onDeny(state);
+      }
+      res.status(errorStatus).json(errorPayload);
+      return;
+    }
+    next();
+  };
+};
+var withSurvival = async (survival, handler, options = {}) => {
+  const allowed = await survival.guard();
+  if (!allowed) {
+    if (options.onDeny) {
+      options.onDeny(survival.getState());
+    }
+    throw new Error("survival_low_funds");
+  }
+  return handler();
+};
+var createSelfRelianceMonitor = (survival, fetchSnapshot, config = {}) => {
+  const intervalMs = config.intervalMs ?? 3e4;
+  let timer = null;
+  let stopped = false;
+  const runOnce = async () => {
+    try {
+      const snapshot = await fetchSnapshot();
+      const state = survival.update(snapshot);
+      if (config.onUpdate) {
+        config.onUpdate(snapshot, state);
+      }
+      await survival.enforce();
+    } catch (err) {
+      if (config.onError) {
+        config.onError(err instanceof Error ? err : new Error("monitor_failed"));
+      }
+    }
+  };
+  const start = async () => {
+    if (timer) return;
+    await runOnce();
+    if (stopped) return;
+    timer = setInterval(runOnce, intervalMs);
+  };
+  const stop = () => {
+    stopped = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return { start, stop, runOnce };
+};
+var createAutoSelfReliance = (options) => {
+  const { survival, fetchSnapshot, intervalMs, onUpdate, onError } = options;
+  return createSelfRelianceMonitor(survival, fetchSnapshot, {
+    intervalMs,
+    onUpdate,
+    onError
+  });
+};
+
+export {
+  SelfReliance,
+  createSelfReliancePolicy,
+  createSurvivalMiddleware,
+  withSurvival,
+  createSelfRelianceMonitor,
+  createAutoSelfReliance
+};

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as _solana_web3_js from '@solana/web3.js';
 import { L as ListingRecord, a as ListingType, b as ListingStatus, C as ClaimPurpose, c as ClaimResponse, V as VerifiedClaimResponse, d as ListingInput, e as ListingReviewRecord, T as TicketVerifyResponse } from './solana-3VMnBZH6.js';
 export { f as fetchSolBalance, g as fetchTokenBalance, h as fetchTokenBalances } from './solana-3VMnBZH6.js';
+import { SelfReliancePolicy } from './selfReliance.js';
 export { SelfReliance, createAutoSelfReliance, createSelfRelianceMonitor, createSelfReliancePolicy, createSurvivalMiddleware, withSurvival } from './selfReliance.js';
 import '@coral-xyz/anchor';
 
@@ -737,9 +738,43 @@ type OpenRouterCredits = {
 type ResourceSnapshot = {
     solBalance?: number;
     openRouterCredits?: number;
+    apiCredits?: Record<string, number>;
     tokenBalances?: Record<string, number>;
     updatedAt?: number;
 };
+type ApiCreditProvider = {
+    name: string;
+    fetchCredits: () => Promise<number>;
+};
+type ApiCreditProviderPreset = 'openrouter' | 'anthropic' | 'gemini' | 'custom';
+type ApiCreditProviderPresetInput = {
+    provider: ApiCreditProviderPreset | string;
+    name?: string;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    endpoint?: string;
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: unknown;
+    creditsPath?: string;
+};
+type ApiCreditProviderFactoryOptions = {
+    apiBase?: string;
+    fetcher?: typeof fetch;
+    resolveSecret?: (name: string) => string | undefined | Promise<string | undefined>;
+};
+type ResourceProviderManifestEntry = {
+    provider: ApiCreditProviderPreset | string;
+    name?: string;
+    apiKeyEnv?: string;
+    endpoint?: string;
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    creditsPath?: string;
+};
+type AgentResourceProvidersManifest = {
+    resourceProviders?: ResourceProviderManifestEntry[];
+};
 interface ListingQuery {
     type?: ListingType;
     status?: ListingStatus;
@@ -871,7 +906,7 @@ declare class ReviewGate {
     assertClear(listingId: string, wallet: string): void;
 }
 
-declare const compareVersions: (currentVersion: string, latestVersion: string) => 0 | 1 | -1;
+declare const compareVersions: (currentVersion: string, latestVersion: string) => 1 | 0 | -1;
 declare const buildSdkUpdateCommand: (packageName?: string) => string;
 declare const checkForSdkUpdate: (options?: SdkUpdateCheckOptions) => Promise<SdkUpdateStatus>;
 declare const checkForSdkUpdatePolicy: (options: SdkUpdatePolicyCheckOptions) => Promise<SdkUpdateStatus>;
@@ -895,6 +930,12 @@ declare class VibeClient {
     registerAgent(claimId: string, listing: ListingInput, ownerClaimId?: string): Promise<ApiResponse<ListingRecord>>;
     updateListingStatus(listingId: string, claimId: string, status: ListingStatus): Promise<ApiResponse<ListingRecord>>;
     updateListingPrice(listingId: string, claimId: string, priceUsdc: number): Promise<ApiResponse<ListingRecord>>;
+    deleteListing(listingId: string, claimId: string): Promise<ApiResponse<{
+        id: string;
+        deleted: boolean;
+        removedStorageObjects?: number;
+        storageCleanupErrors?: string[];
+    }>>;
     transferOwner(listingId: string, claimId: string, signature: string): Promise<ApiResponse<{
         listing_id: string;
         owner_wallet_id: string;
@@ -945,6 +986,7 @@ declare class VibeClient {
     }): Promise<TicketVerifyResponse>;
     private get;
     private post;
+    private del;
     checkLatestVersion(force?: boolean): Promise<SdkUpdateStatus>;
     private resolveUpdateStatus;
     private ensureLatestVersion;
@@ -993,6 +1035,12 @@ declare const buildShareLink: (listingId: string, options?: MarketingLinkOptions
 declare const buildShareCopy: (listing: ListingRecord, options?: MarketingLinkOptions) => string;
 declare const buildBadgeMarkdown: (listing: ListingRecord, options?: MarketingLinkOptions) => string;
 declare const createCampaign: (listingId: string, options?: MarketingLinkOptions) => MarketingCampaign;
+declare const createApiCreditProvider: (input: ApiCreditProviderPresetInput, options?: ApiCreditProviderFactoryOptions) => Promise<ApiCreditProvider>;
+declare const createApiCreditProviders: (inputs: ApiCreditProviderPresetInput[], options?: ApiCreditProviderFactoryOptions) => Promise<ApiCreditProvider[]>;
+declare const createApiCreditProvidersFromManifest: (manifest: AgentResourceProvidersManifest, options?: ApiCreditProviderFactoryOptions) => Promise<ApiCreditProvider[]>;
+declare const assertSurvivalProvidersConfigured: (policy: Pick<SelfReliancePolicy, "openRouterMinCredits" | "openRouterWarnCredits" | "apiMinCredits" | "apiWarnCredits">, providers: ApiCreditProvider[], options?: {
+    hasOpenRouterApiKey?: boolean;
+}) => void;
 declare const buildRaydiumSwapUrl: (tokenMint: string) => string;
 declare const buildJupiterSwapUrl: (tokenMint: string) => string;
 declare const buildTradeLinks: (tokenMint: string) => {
@@ -1005,7 +1053,8 @@ declare const getResourceSnapshot: (options: {
     wallet: string | _solana_web3_js.PublicKey;
     tokenMints?: Array<string | _solana_web3_js.PublicKey>;
     openRouterApiKey?: string;
+    apiCreditProviders?: ApiCreditProvider[];
     apiBase?: string;
 }) => Promise<ResourceSnapshot>;
 
-export { type AnalyticsPoint, type ApiResponse, type BuybackEvent, ClaimPurpose, ClaimResponse, LISTING_NAME_MAX_LENGTH, LISTING_NAME_RECOMMENDED_MAX, LISTING_TAGLINE_MAX_LENGTH, LISTING_TAGLINE_RECOMMENDED_MAX, type LeaderboardEntry, type LeaderboardQuery, ListingInput, type ListingNamingValidationOptions, type ListingNamingValidationResult, type ListingQuery, ListingRecord, type ListingReviewCreatePayload, ListingReviewRecord, type ListingReviewResponsePayload, ListingStatus, ListingType, type ListingVersionPayload, type MarketingCampaign, type MarketingLinkOptions, type MemoryPingChallengeResponse, type MemoryPingPayload, type OpenRouterCredits, type ResourceSnapshot, ReviewGate, type ReviewGateRecord, type ReviewRequiredPayload, type SdkUpdateCheckOptions, type SdkUpdatePolicyCheckOptions, SdkUpdateRequiredError, type SdkUpdateStatus, TicketVerifyResponse, VIBEIAO_IDL, VerifiedClaimResponse, VibeClient, type VibeClientOptions, VibeRegistry, buildBadgeMarkdown, buildClaimMessage, buildJupiterSwapUrl, buildListingVersionMessage, buildMemoryPingMessage, buildOwnerTransferMessage, buildRaydiumSwapUrl, buildReviewPrompt, buildReviewRequired, buildReviewResponseMessage, buildSdkUpdateCommand, buildShareCopy, buildShareLink, buildTradeLinks, checkForSdkUpdate, checkForSdkUpdatePolicy, compareVersions, createCampaign, getResourceSnapshot, normalizeListingText, sanitizeListingNaming, validateListingNaming };
+export { type AgentResourceProvidersManifest, type AnalyticsPoint, type ApiCreditProvider, type ApiCreditProviderFactoryOptions, type ApiCreditProviderPreset, type ApiCreditProviderPresetInput, type ApiResponse, type BuybackEvent, ClaimPurpose, ClaimResponse, LISTING_NAME_MAX_LENGTH, LISTING_NAME_RECOMMENDED_MAX, LISTING_TAGLINE_MAX_LENGTH, LISTING_TAGLINE_RECOMMENDED_MAX, type LeaderboardEntry, type LeaderboardQuery, ListingInput, type ListingNamingValidationOptions, type ListingNamingValidationResult, type ListingQuery, ListingRecord, type ListingReviewCreatePayload, ListingReviewRecord, type ListingReviewResponsePayload, ListingStatus, ListingType, type ListingVersionPayload, type MarketingCampaign, type MarketingLinkOptions, type MemoryPingChallengeResponse, type MemoryPingPayload, type OpenRouterCredits, type ResourceProviderManifestEntry, type ResourceSnapshot, ReviewGate, type ReviewGateRecord, type ReviewRequiredPayload, type SdkUpdateCheckOptions, type SdkUpdatePolicyCheckOptions, SdkUpdateRequiredError, type SdkUpdateStatus, TicketVerifyResponse, VIBEIAO_IDL, VerifiedClaimResponse, VibeClient, type VibeClientOptions, VibeRegistry, assertSurvivalProvidersConfigured, buildBadgeMarkdown, buildClaimMessage, buildJupiterSwapUrl, buildListingVersionMessage, buildMemoryPingMessage, buildOwnerTransferMessage, buildRaydiumSwapUrl, buildReviewPrompt, buildReviewRequired, buildReviewResponseMessage, buildSdkUpdateCommand, buildShareCopy, buildShareLink, buildTradeLinks, checkForSdkUpdate, checkForSdkUpdatePolicy, compareVersions, createApiCreditProvider, createApiCreditProviders, createApiCreditProvidersFromManifest, createCampaign, getResourceSnapshot, normalizeListingText, sanitizeListingNaming, validateListingNaming };

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   createSelfReliancePolicy,
   createSurvivalMiddleware,
   withSurvival
-} from "./chunk-BFAMXH2X.js";
+} from "./chunk-M7DQTU5R.js";
 import {
   VIBEIAO_IDL,
   fetchSolBalance,
@@ -114,7 +114,7 @@ var ReviewGate = class {
 var DEFAULT_API_BASE = "https://api.vibeiao.com";
 var DEFAULT_WEB_BASE = "https://vibeiao.com";
 var DEFAULT_SDK_PACKAGE = "@vibeiao/sdk";
-var DEFAULT_SDK_VERSION = "0.1.7" ? "0.1.7" : "0.1.4";
+var DEFAULT_SDK_VERSION = "0.1.9" ? "0.1.9" : "0.1.4";
 var DEFAULT_SDK_REGISTRY = "https://registry.npmjs.org";
 var DEFAULT_SDK_POLICY_PATH = "/v1/sdk/policy";
 var DEFAULT_SDK_CHECK_INTERVAL_MS = 1e3 * 60 * 30;
@@ -261,6 +261,49 @@ var unwrap = (response) => {
   }
   return response.data;
 };
+var normalizeProviderName = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "");
+var getByPath = (payload, path) => {
+  if (!path) return void 0;
+  const segments = path.split(".").map((part) => part.trim()).filter(Boolean);
+  let current = payload;
+  for (const segment of segments) {
+    if (!current || typeof current !== "object" || !(segment in current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+};
+var extractCreditsFromPayload = (payload, creditsPath) => {
+  const direct = getByPath(payload, creditsPath);
+  let credits = pickFinite(
+    direct,
+    payload?.credits,
+    payload?.remaining_credits,
+    payload?.remainingCredits,
+    payload?.balance,
+    payload?.remaining
+  );
+  if (Number.isFinite(credits)) return credits;
+  const nested = payload?.data;
+  credits = pickFinite(
+    nested?.credits,
+    nested?.remaining_credits,
+    nested?.remainingCredits,
+    nested?.balance,
+    nested?.remaining
+  );
+  return credits;
+};
+var defaultApiKeyEnvForProvider = (provider) => {
+  const normalized = normalizeProviderName(provider);
+  if (normalized === "openrouter") return "OPENROUTER_API_KEY";
+  if (normalized === "anthropic") return "ANTHROPIC_API_KEY";
+  if (normalized === "gemini") return "GEMINI_API_KEY";
+  return `${normalized.toUpperCase()}_API_KEY`;
+};
+var providerConfigError = (providerName, detail, nextStep) => `provider_config_error:${providerName}:${detail}. ${nextStep}`;
+var providerFetchError = (providerName, detail) => `provider_fetch_failed:${providerName}:${detail}`;
 var generateRef = () => {
   const cryptoObj = globalThis.crypto;
   if (cryptoObj?.randomUUID) {
@@ -329,6 +372,12 @@ var VibeClient = class {
   async updateListingPrice(listingId, claimId, priceUsdc) {
     return this.post(`/v1/listings/${listingId}/price`, { claimId, priceUsdc });
   }
+  async deleteListing(listingId, claimId) {
+    return this.del(
+      `/v1/listings/${listingId}`,
+      { claimId }
+    );
+  }
   async transferOwner(listingId, claimId, signature) {
     return this.post(
       `/v1/listings/${listingId}/owner-transfer`,
@@ -539,6 +588,28 @@ var VibeClient = class {
     }
     return payload;
   }
+  async del(path, body) {
+    await this.ensureLatestVersion();
+    const response = await this.fetcher(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    let payload = null;
+    try {
+      payload = await readJson(response);
+    } catch (error) {
+      const details = error instanceof Error && "details" in error ? error.details : void 0;
+      return { error: "invalid_json_response", details };
+    }
+    if (!response.ok) {
+      return { error: payload?.error || "request_failed", details: payload?.details };
+    }
+    if (!payload) {
+      return { error: "empty_response" };
+    }
+    return payload;
+  }
   async checkLatestVersion(force = false) {
     if (!force && this.lastUpdateStatus && Date.now() - this.lastUpdateCheckAt < this.updateCheckIntervalMs) {
       return this.lastUpdateStatus;
@@ -688,6 +759,145 @@ var createCampaign = (listingId, options = {}) => {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 };
+var createApiCreditProvider = async (input, options = {}) => {
+  const providerRaw = String(input.provider || "").trim();
+  const provider = normalizeProviderName(providerRaw || input.name || "custom");
+  const providerName = normalizeProviderName(input.name || provider || "custom");
+  if (!provider) {
+    throw new Error(
+      providerConfigError("unknown", "provider_missing", "Set provider to openrouter/anthropic/gemini/custom.")
+    );
+  }
+  const resolveSecret = options.resolveSecret;
+  const apiKeyEnv = input.apiKeyEnv || defaultApiKeyEnvForProvider(provider);
+  const resolvedSecret = resolveSecret ? await resolveSecret(apiKeyEnv) : void 0;
+  const apiKey = input.apiKey || resolvedSecret;
+  const fetcher = options.fetcher || fetch;
+  if (provider === "openrouter") {
+    if (!apiKey) {
+      throw new Error(
+        providerConfigError(
+          providerName,
+          "api_key_missing",
+          `Ask your human owner to provide ${apiKeyEnv} or set apiKey directly.`
+        )
+      );
+    }
+    return {
+      name: providerName,
+      fetchCredits: async () => {
+        const client = new VibeClient({ baseUrl: options.apiBase, fetcher });
+        const result = await client.getOpenRouterCreditsValue(apiKey);
+        if (result.error) {
+          throw new Error(providerFetchError(providerName, result.error));
+        }
+        return Number(result.data);
+      }
+    };
+  }
+  if (!input.endpoint) {
+    throw new Error(
+      providerConfigError(
+        providerName,
+        "endpoint_missing",
+        "Set endpoint to the provider credit/balance API URL."
+      )
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      providerConfigError(
+        providerName,
+        "api_key_missing",
+        `Ask your human owner to provide ${apiKeyEnv} or set apiKey directly.`
+      )
+    );
+  }
+  return {
+    name: providerName,
+    fetchCredits: async () => {
+      const headers = { ...input.headers || {} };
+      const hasAuthHeader = Object.keys(headers).some((key) => key.toLowerCase() === "authorization");
+      const hasApiKeyHeader = Object.keys(headers).some((key) => key.toLowerCase() === "x-api-key");
+      if (provider === "anthropic") {
+        if (!hasApiKeyHeader) headers["x-api-key"] = apiKey;
+        if (!headers["anthropic-version"]) headers["anthropic-version"] = "2023-06-01";
+      } else if (!hasAuthHeader && !hasApiKeyHeader) {
+        headers.Authorization = `Bearer ${apiKey}`;
+      }
+      const method = input.method || (input.body !== void 0 ? "POST" : "GET");
+      const hasContentType = Object.keys(headers).some((key) => key.toLowerCase() === "content-type");
+      const body = input.body !== void 0 ? typeof input.body === "string" ? input.body : JSON.stringify(input.body) : void 0;
+      if (body && !hasContentType) {
+        headers["Content-Type"] = "application/json";
+      }
+      let response;
+      try {
+        response = await fetcher(input.endpoint, { method, headers, body });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "network_error";
+        throw new Error(providerFetchError(providerName, message));
+      }
+      const payload = await readJson(response);
+      if (!response.ok) {
+        const detail = String(payload?.error || `http_${response.status}`);
+        throw new Error(providerFetchError(providerName, detail));
+      }
+      const credits = extractCreditsFromPayload(payload, input.creditsPath);
+      if (!Number.isFinite(credits)) {
+        throw new Error(
+          providerFetchError(
+            providerName,
+            `credits_unavailable (set creditsPath, current=${input.creditsPath || "auto"})`
+          )
+        );
+      }
+      return credits;
+    }
+  };
+};
+var createApiCreditProviders = async (inputs, options = {}) => {
+  const providers = [];
+  for (const input of inputs) {
+    providers.push(await createApiCreditProvider(input, options));
+  }
+  return providers;
+};
+var createApiCreditProvidersFromManifest = async (manifest, options = {}) => {
+  const entries = manifest.resourceProviders || [];
+  const configs = entries.map((entry) => ({
+    provider: entry.provider,
+    name: entry.name,
+    apiKeyEnv: entry.apiKeyEnv,
+    endpoint: entry.endpoint,
+    method: entry.method,
+    headers: entry.headers,
+    creditsPath: entry.creditsPath
+  }));
+  return createApiCreditProviders(configs, options);
+};
+var assertSurvivalProvidersConfigured = (policy, providers, options = {}) => {
+  const required = /* @__PURE__ */ new Set();
+  if (policy.openRouterMinCredits !== void 0 || policy.openRouterWarnCredits !== void 0) {
+    required.add("openrouter");
+  }
+  const addFromMap = (map) => {
+    if (!map) return;
+    Object.keys(map).forEach((name) => required.add(normalizeProviderName(name)));
+  };
+  addFromMap(policy.apiMinCredits);
+  addFromMap(policy.apiWarnCredits);
+  const available = new Set((providers || []).map((provider) => normalizeProviderName(provider.name)));
+  if (options.hasOpenRouterApiKey) {
+    available.add("openrouter");
+  }
+  const missing = Array.from(required).filter((name) => !available.has(name));
+  if (missing.length) {
+    throw new Error(
+      `survival_provider_missing:${missing.join(",")}. Configure apiCreditProviders (or api keys), or remove thresholds for missing providers.`
+    );
+  }
+};
 var buildRaydiumSwapUrl = (tokenMint) => `https://raydium.io/swap/?inputCurrency=sol&outputCurrency=${tokenMint}`;
 var buildJupiterSwapUrl = (tokenMint) => `https://jup.ag/swap/SOL-${tokenMint}`;
 var buildTradeLinks = (tokenMint) => ({
@@ -695,8 +905,9 @@ var buildTradeLinks = (tokenMint) => ({
   jupiter: buildJupiterSwapUrl(tokenMint)
 });
 var getResourceSnapshot = async (options) => {
-  const { connection, wallet, tokenMints, openRouterApiKey, apiBase } = options;
+  const { connection, wallet, tokenMints, openRouterApiKey, apiCreditProviders, apiBase } = options;
   const snapshot = { updatedAt: Date.now() };
+  const apiCredits = {};
   snapshot.solBalance = await fetchSolBalance(connection, wallet);
   if (tokenMints?.length) {
     snapshot.tokenBalances = await fetchTokenBalances(connection, wallet, tokenMints);
@@ -708,6 +919,33 @@ var getResourceSnapshot = async (options) => {
       throw new Error(credits.error);
     }
     snapshot.openRouterCredits = credits.data;
+    apiCredits.openrouter = credits.data;
+  }
+  if (apiCreditProviders?.length) {
+    for (const provider of apiCreditProviders) {
+      const name = String(provider?.name || "").trim().toLowerCase();
+      if (!name || typeof provider.fetchCredits !== "function") continue;
+      try {
+        const value = Number(await provider.fetchCredits());
+        if (Number.isFinite(value)) {
+          apiCredits[name] = value;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown_error";
+        throw new Error(
+          providerFetchError(
+            name,
+            `${message}. Ask your human owner to provision/refill this provider key if needed.`
+          )
+        );
+      }
+    }
+  }
+  if (Object.keys(apiCredits).length > 0) {
+    snapshot.apiCredits = apiCredits;
+    if (snapshot.openRouterCredits === void 0 && apiCredits.openrouter !== void 0) {
+      snapshot.openRouterCredits = apiCredits.openrouter;
+    }
   }
   return snapshot;
 };
@@ -722,6 +960,7 @@ export {
   VIBEIAO_IDL,
   VibeClient,
   VibeRegistry,
+  assertSurvivalProvidersConfigured,
   buildBadgeMarkdown,
   buildClaimMessage,
   buildJupiterSwapUrl,
@@ -739,6 +978,9 @@ export {
   checkForSdkUpdate,
   checkForSdkUpdatePolicy,
   compareVersions,
+  createApiCreditProvider,
+  createApiCreditProviders,
+  createApiCreditProvidersFromManifest,
   createAutoSelfReliance,
   createCampaign,
   createSelfRelianceMonitor,

package/dist/selfReliance.d.ts

@@ -3,6 +3,8 @@ type SelfReliancePolicy = {
     solWarnBalance: number;
     openRouterMinCredits?: number;
     openRouterWarnCredits?: number;
+    apiMinCredits?: Record<string, number>;
+    apiWarnCredits?: Record<string, number>;
     allowIfLow?: boolean;
     denyMode?: 'any' | 'all';
     solHardMin?: number;
@@ -12,6 +14,7 @@ type SelfReliancePolicy = {
 type SelfRelianceState = {
     solBalance?: number;
     openRouterCredits?: number;
+    apiCredits?: Record<string, number>;
     lastWarnAt?: number;
     lastUpdatedAt?: number;
 };
@@ -27,6 +30,7 @@ type SelfRelianceConfig = {
 type ResourceSnapshot = {
     solBalance?: number;
     openRouterCredits?: number;
+    apiCredits?: Record<string, number>;
     tokenBalances?: Record<string, number>;
     updatedAt?: number;
 };
@@ -39,6 +43,7 @@ declare class SelfReliance {
     getState(): {
         solBalance?: number;
         openRouterCredits?: number;
+        apiCredits?: Record<string, number>;
         lastWarnAt?: number;
         lastUpdatedAt?: number;
     };

package/dist/selfReliance.js

@@ -5,7 +5,7 @@ import {
   createSelfReliancePolicy,
   createSurvivalMiddleware,
   withSurvival
-} from "./chunk-BFAMXH2X.js";
+} from "./chunk-M7DQTU5R.js";
 export {
   SelfReliance,
   createAutoSelfReliance,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vibeiao/sdk",
   "private": false,
   "type": "module",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {