@anhlp/alp-runtime 0.0.0-stage → 0.0.1-beta.4

package/dist/runtime-context.d.ts

@@ -0,0 +1,43 @@
+export declare const COMPACT_SHARE = 0.9;
+/** Bounded optional reads. Never expose account identifiers or credentials. */
+export declare function optionalRead<T>(read: () => Promise<T>, timeout?: number): Promise<T | undefined>;
+export declare function codexUsage(result: any): {
+    available: boolean;
+    ordinaryUsageAllowed?: undefined;
+    limits?: undefined;
+} | {
+    available: boolean;
+    ordinaryUsageAllowed: any;
+    limits: {
+        name: any;
+        model: any;
+        plan: any;
+        windows: {
+            usedPercent: any;
+            remainingPercent: number | null;
+            windowMinutes: any;
+            resetsAt: any;
+        }[];
+        spendControlReached: any;
+    }[];
+};
+export declare function claudeUsage(result: any): {
+    available: boolean;
+    plan?: undefined;
+    windows?: undefined;
+} | {
+    available: boolean;
+    plan: any;
+    windows: {
+        name: string;
+        usedPercent: any;
+        remainingPercent: number | null;
+        resetsAt: any;
+    }[];
+};
+/**
+ * Whether a runtime's usage report (codexUsage or claudeUsage) lets it work again (ALPD §58):
+ * true when every window has room, false on explicit provider denial, a used-up window or spending cap, and
+ * undefined when the report says nothing either way.
+ */
+export declare function usageAllows(usage: any): boolean | undefined;

package/dist/runtime-context.js

@@ -0,0 +1,61 @@
+// packages/runtime/src/runtime-context.ts
+var COMPACT_SHARE = 0.9;
+async function optionalRead(read, timeout = 1500) {
+  let timer;
+  try {
+    return await Promise.race([Promise.resolve().then(read).catch(() => void 0), new Promise((resolve) => {
+      timer = setTimeout(() => resolve(void 0), timeout);
+    })]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function codexUsage(result) {
+  if (!result?.rateLimits) return { available: false };
+  const clean = (limit) => ({
+    name: limit?.limitName ?? null,
+    model: limit?.normalModelSlug ?? null,
+    plan: limit?.planType ?? null,
+    windows: [limit?.primary, limit?.secondary].filter(Boolean).map((window) => ({
+      usedPercent: window.usedPercent,
+      remainingPercent: typeof window.usedPercent === "number" ? Math.max(0, 100 - window.usedPercent) : null,
+      windowMinutes: window.windowDurationMins,
+      resetsAt: window.resetsAt
+    })),
+    spendControlReached: limit?.spendControlReached ?? null
+  });
+  return {
+    available: true,
+    ordinaryUsageAllowed: result.ordinaryUsageAllowed ?? null,
+    limits: Object.values(result.rateLimitsByLimitId ?? { default: result.rateLimits }).map(clean)
+  };
+}
+function claudeUsage(result) {
+  if (!result) return { available: false };
+  return {
+    available: result.rate_limits_available === true,
+    plan: result.subscription_type ?? null,
+    windows: Object.entries(result.rate_limits ?? {}).flatMap(([name, window]) => window && "utilization" in window ? [{
+      name,
+      usedPercent: window.utilization,
+      remainingPercent: typeof window.utilization === "number" ? Math.max(0, 100 - window.utilization) : null,
+      resetsAt: window.resets_at
+    }] : [])
+  };
+}
+function usageAllows(usage) {
+  if (!usage?.available) return void 0;
+  const limits = Array.isArray(usage.limits) ? usage.limits : [];
+  if (usage.ordinaryUsageAllowed === false || limits.some((limit) => limit?.spendControlReached === true)) return false;
+  const windows = limits.length ? limits.flatMap((limit) => limit?.windows ?? []) : usage.windows ?? [];
+  const known = windows.filter((window) => typeof window?.usedPercent === "number");
+  if (!known.length) return void 0;
+  return known.every((window) => window.usedPercent < 100);
+}
+export {
+  COMPACT_SHARE,
+  claudeUsage,
+  codexUsage,
+  optionalRead,
+  usageAllows
+};

package/dist/runtime.d.ts

@@ -0,0 +1,11 @@
+import { type RuntimeOptions, type AlpRuntime } from './contracts.js';
+export type { RuntimeTransport, RuntimeOptions, OpenOptions, PromptContent, PromptInput, AlpRuntime, SessionPreview, RecoveryOutcome, Pause, PauseState, RecallAnswer } from './contracts.js';
+export { DEFAULT_TEAM } from './contracts.js';
+export type WorkspaceMutationReason = 'workspace_busy' | 'workspace_claimed' | 'workspace_leased' | 'workspace_assignment_result';
+export declare class WorkspaceMutationError extends Error {
+    readonly data: {
+        reason: WorkspaceMutationReason;
+    };
+    constructor(reason: WorkspaceMutationReason, message: string);
+}
+export declare function createAlpRuntime(options?: RuntimeOptions): AlpRuntime;