@agentforge-io/core 0.2.0

package/dist/adapters/rate-limiter/in-memory.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryRateLimiter = void 0;
+/**
+ * Fixed-window counter. Each key gets a bucket holding the current count and
+ * the window-start timestamp; the bucket resets when the window expires.
+ *
+ * Single-instance only — counters live in process memory. For multi-instance
+ * deploys use `RedisRateLimiter`, which shares counters across nodes via INCR.
+ */
+class InMemoryRateLimiter {
+    constructor(opts = {}) {
+        this.buckets = new Map();
+        const interval = opts.cleanupIntervalMs ?? 60_000;
+        // Don't keep the event loop alive just for cleanup.
+        if (interval > 0 && typeof setInterval === 'function') {
+            this.cleanupInterval = setInterval(() => this.evictExpired(), interval);
+            // Node-specific: don't block process exit.
+            this.cleanupInterval.unref?.();
+        }
+        else {
+            this.cleanupInterval = null;
+        }
+    }
+    async consume(key, opts) {
+        const now = Date.now();
+        const bucket = this.buckets.get(key);
+        if (!bucket || now - bucket.windowStartedAt >= opts.windowMs) {
+            this.buckets.set(key, { count: 1, windowStartedAt: now });
+            return {
+                allowed: true,
+                remaining: Math.max(0, opts.max - 1),
+                retryAfterMs: opts.windowMs,
+            };
+        }
+        bucket.count += 1;
+        const allowed = bucket.count <= opts.max;
+        const retryAfterMs = Math.max(0, opts.windowMs - (now - bucket.windowStartedAt));
+        return {
+            allowed,
+            remaining: Math.max(0, opts.max - bucket.count),
+            retryAfterMs,
+        };
+    }
+    /** Stops the periodic cleanup. Call when shutting down a test or worker. */
+    close() {
+        if (this.cleanupInterval)
+            clearInterval(this.cleanupInterval);
+    }
+    evictExpired() {
+        const now = Date.now();
+        // Without per-key window sizes recorded we evict bucket entries that have
+        // been idle for more than an hour — long enough for any sane window to
+        // have elapsed, short enough to keep memory bounded.
+        const idleThresholdMs = 60 * 60 * 1000;
+        for (const [key, bucket] of this.buckets) {
+            if (now - bucket.windowStartedAt > idleThresholdMs) {
+                this.buckets.delete(key);
+            }
+        }
+    }
+}
+exports.InMemoryRateLimiter = InMemoryRateLimiter;

package/dist/adapters/rate-limiter/rate-limiter.types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Pluggable rate-limiter contract. Used by adapters (Express middleware,
+ * Nest guard) to gate sensitive endpoints — anti brute-force on /auth/login,
+ * anti enumeration on /auth/request-password-reset, anti abuse on register.
+ *
+ * Two implementations ship with @agentforge-io/core:
+ *   - InMemoryRateLimiter — fixed-window counter per key. Default for
+ *     single-instance deploys; counters reset on process restart.
+ *   - RedisRateLimiter — INCR + EXPIRE per (key, window). Use when you run
+ *     more than one API instance: counters are shared across them.
+ *
+ * Distinct from `UsageService.checkLimits` / `TenantBillingService.checkLimits`,
+ * which enforce monthly billing quotas. A rate-limiter caps short-window
+ * request volume and returns 429; quotas cap monthly spend and return 403.
+ */
+export interface RateLimitOptions {
+    /** Length of the window in milliseconds. */
+    windowMs: number;
+    /** Maximum number of consumed tokens permitted within the window. */
+    max: number;
+}
+export interface RateLimitResult {
+    /** True when the request is below the cap and may proceed. */
+    allowed: boolean;
+    /** Remaining permitted requests in the current window. Never negative. */
+    remaining: number;
+    /** Milliseconds until the window resets. Always set, even when `allowed`. */
+    retryAfterMs: number;
+}
+export interface RateLimiter {
+    /**
+     * Record one consumed token for `key` under `opts`. Returns the new state.
+     * Implementations MUST be idempotent on a per-call basis — every call counts
+     * as exactly one request, even when `allowed: false`.
+     *
+     * The `key` is whatever the adapter chose to bucket on: an IP for
+     * unauthenticated endpoints, a userId for authenticated rate-limits, a
+     * (tenantId, route) pair for API keys. The limiter does not interpret it.
+     */
+    consume(key: string, opts: RateLimitOptions): Promise<RateLimitResult>;
+}
+export declare const RATE_LIMITER = "AGENTFORGE_RATE_LIMITER";

package/dist/adapters/rate-limiter/rate-limiter.types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RATE_LIMITER = void 0;
+// String token (not Symbol) so it survives duplicate package instances.
+exports.RATE_LIMITER = 'AGENTFORGE_RATE_LIMITER';

package/dist/adapters/rate-limiter/redis.d.ts

@@ -0,0 +1,31 @@
+import type { RateLimitOptions, RateLimitResult, RateLimiter } from './rate-limiter.types';
+/**
+ * Minimal subset of the Redis client surface this adapter needs. `ioredis`
+ * and `redis` both satisfy it structurally — we don't import either to keep
+ * `@agentforge-io/core` framework- and dep-free.
+ */
+export interface RedisLike {
+    incr(key: string): Promise<number>;
+    /** Sets the TTL in milliseconds. */
+    pexpire(key: string, ms: number): Promise<number>;
+    /** Time-to-live in milliseconds. Returns -1 if no TTL, -2 if missing. */
+    pttl(key: string): Promise<number>;
+}
+/**
+ * Fixed-window counter backed by Redis. The key holds the request count for
+ * the current window; the TTL is set on the first INCR of each window so
+ * the counter resets cleanly when the window expires.
+ *
+ * Designed for multi-instance deploys: every API node hits the same Redis,
+ * so a brute-force attempt spread across all nodes still hits the cap.
+ *
+ * Two round-trips per call in the worst case (INCR + PEXPIRE on the first
+ * request of a window; INCR + PTTL on subsequent ones). Acceptable for the
+ * auth-rate-limit path; if you need lower latency on a hotter endpoint, use
+ * a Lua script that does both atomically.
+ */
+export declare class RedisRateLimiter implements RateLimiter {
+    private readonly redis;
+    constructor(redis: RedisLike);
+    consume(key: string, opts: RateLimitOptions): Promise<RateLimitResult>;
+}

package/dist/adapters/rate-limiter/redis.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisRateLimiter = void 0;
+const KEY_PREFIX = 'af:rl:';
+/**
+ * Fixed-window counter backed by Redis. The key holds the request count for
+ * the current window; the TTL is set on the first INCR of each window so
+ * the counter resets cleanly when the window expires.
+ *
+ * Designed for multi-instance deploys: every API node hits the same Redis,
+ * so a brute-force attempt spread across all nodes still hits the cap.
+ *
+ * Two round-trips per call in the worst case (INCR + PEXPIRE on the first
+ * request of a window; INCR + PTTL on subsequent ones). Acceptable for the
+ * auth-rate-limit path; if you need lower latency on a hotter endpoint, use
+ * a Lua script that does both atomically.
+ */
+class RedisRateLimiter {
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async consume(key, opts) {
+        const redisKey = KEY_PREFIX + key;
+        const count = await this.redis.incr(redisKey);
+        let ttlMs;
+        if (count === 1) {
+            // First hit of a new window — set the TTL.
+            await this.redis.pexpire(redisKey, opts.windowMs);
+            ttlMs = opts.windowMs;
+        }
+        else {
+            ttlMs = await this.redis.pttl(redisKey);
+            // -1: key exists but has no TTL (race with eviction or a manual SET).
+            // Restore a TTL so the counter resets eventually.
+            if (ttlMs < 0) {
+                await this.redis.pexpire(redisKey, opts.windowMs);
+                ttlMs = opts.windowMs;
+            }
+        }
+        return {
+            allowed: count <= opts.max,
+            remaining: Math.max(0, opts.max - count),
+            retryAfterMs: ttlMs,
+        };
+    }
+}
+exports.RedisRateLimiter = RedisRateLimiter;

package/dist/adapters/upload/noop.adapter.d.ts

@@ -0,0 +1,9 @@
+import type { UploadAdapter } from './upload-adapter.interface';
+/**
+ * Used when no upload adapter is wired. Any sign request throws so the
+ * controller returns a clear 501 to the client instead of pretending to
+ * generate a URL that nobody can PUT to.
+ */
+export declare class NoopUploadAdapter implements UploadAdapter {
+    signUpload(): Promise<never>;
+}

package/dist/adapters/upload/noop.adapter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopUploadAdapter = void 0;
+/**
+ * Used when no upload adapter is wired. Any sign request throws so the
+ * controller returns a clear 501 to the client instead of pretending to
+ * generate a URL that nobody can PUT to.
+ */
+class NoopUploadAdapter {
+    async signUpload() {
+        throw new Error('Uploads are not configured. Pass an UploadAdapter (e.g. S3UploadAdapter) when creating AgentForge.');
+    }
+}
+exports.NoopUploadAdapter = NoopUploadAdapter;

package/dist/adapters/upload/s3.adapter.d.ts

@@ -0,0 +1,38 @@
+import type { SignUploadInput, SignedUploadTarget, UploadAdapter } from './upload-adapter.interface';
+export interface S3UploadAdapterOptions {
+    region: string;
+    bucket: string;
+    /** AWS access key id. Omit when running on an EC2/EKS instance with an IAM
+     *  role — the SDK's default credential chain picks it up. */
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    /**
+     * Public URL prefix the object will be reachable at. Required because we
+     * don't assume CloudFront vs raw S3 vs custom domain. The adapter
+     * concatenates `${publicUrlBase}/${key}` for `publicUrl`.
+     * Examples:
+     *   "https://my-bucket.s3.us-east-1.amazonaws.com"
+     *   "https://cdn.example.com"
+     */
+    publicUrlBase: string;
+    /** PUT URL TTL in seconds. Short by default so the upload window can't be
+     *  reused by a leaked URL hours later. */
+    signedUrlTtlSeconds?: number;
+}
+/**
+ * S3 (or S3-compatible — R2, Spaces, MinIO) signed-upload adapter. Uses the
+ * official AWS SDK v3 so it talks to any provider that implements the S3 API.
+ *
+ * Read access model: the adapter assumes objects are world-readable once
+ * uploaded (`publicUrlBase` is GETtable). If your bucket is private and you
+ * need signed GETs at read-time too, fork this adapter — the interface is
+ * intentionally minimal.
+ */
+export declare class S3UploadAdapter implements UploadAdapter {
+    private readonly client;
+    private readonly bucket;
+    private readonly publicUrlBase;
+    private readonly ttl;
+    constructor(opts: S3UploadAdapterOptions);
+    signUpload(input: SignUploadInput): Promise<SignedUploadTarget>;
+}

package/dist/adapters/upload/s3.adapter.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3UploadAdapter = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+/**
+ * S3 (or S3-compatible — R2, Spaces, MinIO) signed-upload adapter. Uses the
+ * official AWS SDK v3 so it talks to any provider that implements the S3 API.
+ *
+ * Read access model: the adapter assumes objects are world-readable once
+ * uploaded (`publicUrlBase` is GETtable). If your bucket is private and you
+ * need signed GETs at read-time too, fork this adapter — the interface is
+ * intentionally minimal.
+ */
+class S3UploadAdapter {
+    constructor(opts) {
+        if (!opts.bucket)
+            throw new Error('S3UploadAdapter: bucket is required');
+        if (!opts.region)
+            throw new Error('S3UploadAdapter: region is required');
+        if (!opts.publicUrlBase) {
+            throw new Error('S3UploadAdapter: publicUrlBase is required');
+        }
+        this.bucket = opts.bucket;
+        this.publicUrlBase = opts.publicUrlBase.replace(/\/+$/, '');
+        this.ttl = opts.signedUrlTtlSeconds ?? 300;
+        this.client = new client_s3_1.S3Client({
+            region: opts.region,
+            // Only override credentials when explicit keys were passed. Otherwise
+            // let the SDK fall through to its standard provider chain (env vars,
+            // shared credentials file, IAM role, etc.) — that's what production
+            // deployments on AWS expect.
+            ...(opts.accessKeyId && opts.secretAccessKey
+                ? {
+                    credentials: {
+                        accessKeyId: opts.accessKeyId,
+                        secretAccessKey: opts.secretAccessKey,
+                    },
+                }
+                : {}),
+        });
+    }
+    async signUpload(input) {
+        if (!input.key)
+            throw new Error('signUpload: key is required');
+        if (!input.contentType)
+            throw new Error('signUpload: contentType is required');
+        const cmd = new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: input.key,
+            ContentType: input.contentType,
+            // ContentLength can't be locked into a presigned URL on plain S3 — the
+            // SDK only includes signed headers, and the client controls the
+            // Content-Length header. Enforce size at the app layer (callers
+            // check the response Content-Length on a HEAD after upload, or trust
+            // the size they already validated client-side).
+        });
+        const uploadUrl = await (0, s3_request_presigner_1.getSignedUrl)(this.client, cmd, {
+            expiresIn: this.ttl,
+        });
+        return {
+            uploadUrl,
+            publicUrl: `${this.publicUrlBase}/${input.key}`,
+            key: input.key,
+            expiresInSeconds: this.ttl,
+        };
+    }
+}
+exports.S3UploadAdapter = S3UploadAdapter;

package/dist/adapters/upload/upload-adapter.interface.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Provider-agnostic contract for object storage. The default adapter signs
+ * S3 PUTs; consumers running on R2, Backblaze B2, or Supabase Storage can
+ * write their own and pass it to `createAgentForge({ adapters: { upload } })`.
+ *
+ * Direct-upload flow (signed PUT) instead of streaming through our backend:
+ *   1. Client asks us for a signed URL.
+ *   2. We validate intent (MIME, size, scope), generate a key, sign the PUT.
+ *   3. Client uploads the bytes straight to the storage provider.
+ *   4. The persisted `publicUrl` is what other clients read later.
+ */
+export interface SignedUploadTarget {
+    /** Pre-authorized URL the client PUTs the file body to. Short-lived. */
+    uploadUrl: string;
+    /** The eventual GETtable URL once the upload finishes. */
+    publicUrl: string;
+    /** Object key inside the bucket — useful when callers want to associate
+     *  the upload with a domain entity for later cleanup. */
+    key: string;
+    /** Seconds until `uploadUrl` stops being honored by the provider. */
+    expiresInSeconds: number;
+}
+export interface SignUploadInput {
+    /** Object key path. Adapter is free to add randomness for collision safety. */
+    key: string;
+    /** Content-Type the client will declare on PUT. Adapters MUST require the
+     *  same value at PUT time so a different MIME can't be smuggled in. */
+    contentType: string;
+    /** Max content-length the signed URL will accept. Soft hint to the adapter
+     *  — providers that don't support content-length pre-sign should still
+     *  return the URL and rely on app-level validation. */
+    maxSizeBytes?: number;
+}
+export interface UploadAdapter {
+    signUpload(input: SignUploadInput): Promise<SignedUploadTarget>;
+}
+export declare const UPLOAD_ADAPTER = "AGENTFORGE_UPLOAD_ADAPTER";

package/dist/adapters/upload/upload-adapter.interface.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Provider-agnostic contract for object storage. The default adapter signs
+ * S3 PUTs; consumers running on R2, Backblaze B2, or Supabase Storage can
+ * write their own and pass it to `createAgentForge({ adapters: { upload } })`.
+ *
+ * Direct-upload flow (signed PUT) instead of streaming through our backend:
+ *   1. Client asks us for a signed URL.
+ *   2. We validate intent (MIME, size, scope), generate a key, sign the PUT.
+ *   3. Client uploads the bytes straight to the storage provider.
+ *   4. The persisted `publicUrl` is what other clients read later.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPLOAD_ADAPTER = void 0;
+exports.UPLOAD_ADAPTER = 'AGENTFORGE_UPLOAD_ADAPTER';

package/dist/ai/index.d.ts

@@ -0,0 +1,15 @@
+export { AGENT_FORGE_CONFIG, AGENT_QUEUE_NAME, CURRENT_USER, } from '../constants';
+export type { AgentDefinition, AnthropicConfig, McpServerConfig, AgentForgeConfig, DatabaseConfig, RedisConfig, QueueConfig, } from '../types/config.types';
+export type { AgentResponse, AgentOverrides, StreamChunk, TokenUsage, ToolCallRecord, AgentToolDefinition, AgentJobPayload, AgentJobResult, AnthropicMessage, } from '../types/agent.types';
+export type { SdkHooks, UsageEvent, TurnCompleteEvent, ToolCallEvent, } from '../types/hooks';
+export { ToolRegistryService, type Logger } from '../services/tool-registry.service';
+export { AgentRunnerService } from '../services/agent-runner.service';
+export { OrchestratorService } from '../services/orchestrator.service';
+export { PreparedStreamService, PreparedStreamError, } from '../services/prepared-stream.service';
+export { ConversationService, ConversationNotFoundError } from '../services/conversation.service';
+export { AgentService, AgentForbiddenError, type AgentNotFoundError, type AgentResolver, type AgentRecord, type AgentResolveParams, } from '../services/agent.service';
+export { AgentJobWorker } from '../services/agent-job.worker';
+export { PREPARED_STREAM_STORE, type PreparedStreamStore, type PreparedStreamPayload, } from '../adapters/prepared-stream/prepared-stream.types';
+export { InMemoryPreparedStreamStore } from '../services/in-memory-prepared-stream.store';
+export { JOB_QUEUE, type JobQueue, type JobStatus, type JobState, type JobContext, type JobProcessor, type EnqueueOptions, type QueueMetrics, } from '../adapters/job-queue/job-queue.types';
+export { InMemoryJobQueue, type InMemoryJobQueueOptions, } from '../adapters/job-queue/in-memory';

package/dist/ai/index.js

@@ -0,0 +1,43 @@
+"use strict";
+// ─── @agentforge-io/core/ai — narrow surface for AI runtime code ─────────────
+//
+// This sub-path exposes ONLY the AI runtime slice (agent loop, orchestration,
+// tools, conversations, streaming, hooks). Pair with `@agentforge-io/core/billing`
+// for the commercial half. Code that imports from here should compile without
+// ever loading Stripe, billing services, plan logic, etc.
+//
+// Files still co-located physically; this is a logical seam.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryJobQueue = exports.JOB_QUEUE = exports.InMemoryPreparedStreamStore = exports.PREPARED_STREAM_STORE = exports.AgentJobWorker = exports.AgentForbiddenError = exports.AgentService = exports.ConversationNotFoundError = exports.ConversationService = exports.PreparedStreamError = exports.PreparedStreamService = exports.OrchestratorService = exports.AgentRunnerService = exports.ToolRegistryService = exports.CURRENT_USER = exports.AGENT_QUEUE_NAME = exports.AGENT_FORGE_CONFIG = void 0;
+// ─── Constants ─────────────────────────────────────────────────────────────
+var constants_1 = require("../constants");
+Object.defineProperty(exports, "AGENT_FORGE_CONFIG", { enumerable: true, get: function () { return constants_1.AGENT_FORGE_CONFIG; } });
+Object.defineProperty(exports, "AGENT_QUEUE_NAME", { enumerable: true, get: function () { return constants_1.AGENT_QUEUE_NAME; } });
+Object.defineProperty(exports, "CURRENT_USER", { enumerable: true, get: function () { return constants_1.CURRENT_USER; } });
+// ─── Services ──────────────────────────────────────────────────────────────
+var tool_registry_service_1 = require("../services/tool-registry.service");
+Object.defineProperty(exports, "ToolRegistryService", { enumerable: true, get: function () { return tool_registry_service_1.ToolRegistryService; } });
+var agent_runner_service_1 = require("../services/agent-runner.service");
+Object.defineProperty(exports, "AgentRunnerService", { enumerable: true, get: function () { return agent_runner_service_1.AgentRunnerService; } });
+var orchestrator_service_1 = require("../services/orchestrator.service");
+Object.defineProperty(exports, "OrchestratorService", { enumerable: true, get: function () { return orchestrator_service_1.OrchestratorService; } });
+var prepared_stream_service_1 = require("../services/prepared-stream.service");
+Object.defineProperty(exports, "PreparedStreamService", { enumerable: true, get: function () { return prepared_stream_service_1.PreparedStreamService; } });
+Object.defineProperty(exports, "PreparedStreamError", { enumerable: true, get: function () { return prepared_stream_service_1.PreparedStreamError; } });
+var conversation_service_1 = require("../services/conversation.service");
+Object.defineProperty(exports, "ConversationService", { enumerable: true, get: function () { return conversation_service_1.ConversationService; } });
+Object.defineProperty(exports, "ConversationNotFoundError", { enumerable: true, get: function () { return conversation_service_1.ConversationNotFoundError; } });
+var agent_service_1 = require("../services/agent.service");
+Object.defineProperty(exports, "AgentService", { enumerable: true, get: function () { return agent_service_1.AgentService; } });
+Object.defineProperty(exports, "AgentForbiddenError", { enumerable: true, get: function () { return agent_service_1.AgentForbiddenError; } });
+var agent_job_worker_1 = require("../services/agent-job.worker");
+Object.defineProperty(exports, "AgentJobWorker", { enumerable: true, get: function () { return agent_job_worker_1.AgentJobWorker; } });
+// ─── Adapters used by the runtime ──────────────────────────────────────────
+var prepared_stream_types_1 = require("../adapters/prepared-stream/prepared-stream.types");
+Object.defineProperty(exports, "PREPARED_STREAM_STORE", { enumerable: true, get: function () { return prepared_stream_types_1.PREPARED_STREAM_STORE; } });
+var in_memory_prepared_stream_store_1 = require("../services/in-memory-prepared-stream.store");
+Object.defineProperty(exports, "InMemoryPreparedStreamStore", { enumerable: true, get: function () { return in_memory_prepared_stream_store_1.InMemoryPreparedStreamStore; } });
+var job_queue_types_1 = require("../adapters/job-queue/job-queue.types");
+Object.defineProperty(exports, "JOB_QUEUE", { enumerable: true, get: function () { return job_queue_types_1.JOB_QUEUE; } });
+var in_memory_1 = require("../adapters/job-queue/in-memory");
+Object.defineProperty(exports, "InMemoryJobQueue", { enumerable: true, get: function () { return in_memory_1.InMemoryJobQueue; } });

package/dist/billing/index.d.ts

@@ -0,0 +1,12 @@
+export type { Plan, NewPlan, PlanPatch, UsageLimits, } from '../domain/plan';
+export type { Subscription, NewSubscription, SubscriptionPatch, } from '../domain/subscription';
+export type { SubscriptionStatus, PaymentStatus, UserSubscription, UsageSummary, UsageRecord, CheckoutResult, PortalResult, BillingOverviewResult, InvoiceRecord, } from '../types/billing.types';
+export type { BillingProvider, BillingModel, BillingConfig, StripeConfig, PlanDefinition, CreditsConfig, } from '../types/config.types';
+export type { PlanRepository, SubscriptionRepository, UsageRecordRepository, } from '../repositories';
+export type { IBillingAdapter } from '../adapters/billing/billing-adapter.interface';
+export { BILLING_ADAPTER } from '../adapters/billing/billing-adapter.interface';
+export { StripeAdapter } from '../adapters/billing/stripe/stripe.adapter';
+export { UsageService, type UsageServiceOptions } from '../services/usage.service';
+export { PlanService } from '../services/plan.service';
+export { BillingService } from '../services/billing.service';
+export { TenantBillingService } from '../services/tenant-billing.service';

package/dist/billing/index.js

@@ -0,0 +1,28 @@
+"use strict";
+// ─── @agentforge/core/billing — narrow surface for commercial code ─────────
+//
+// This sub-path exposes ONLY the billing/commercial slice of the core
+// library. Consumers that don't want to pull in the full AI surface (and
+// don't want their type-checker to suggest AI internals on autocomplete)
+// can import from here.
+//
+// Architecturally the files still live alongside the AI code in
+// `packages/core/src/`; this is a narrowed re-export, not a physical move.
+// The goal is to make the seam visible and lintable today, and to make a
+// later physical extraction (to `apps/server/modules/billing/`, or to a
+// separate `@agentforge/billing` package) a localized change.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantBillingService = exports.BillingService = exports.PlanService = exports.UsageService = exports.StripeAdapter = exports.BILLING_ADAPTER = void 0;
+var billing_adapter_interface_1 = require("../adapters/billing/billing-adapter.interface");
+Object.defineProperty(exports, "BILLING_ADAPTER", { enumerable: true, get: function () { return billing_adapter_interface_1.BILLING_ADAPTER; } });
+var stripe_adapter_1 = require("../adapters/billing/stripe/stripe.adapter");
+Object.defineProperty(exports, "StripeAdapter", { enumerable: true, get: function () { return stripe_adapter_1.StripeAdapter; } });
+// ─── Services ──────────────────────────────────────────────────────────────
+var usage_service_1 = require("../services/usage.service");
+Object.defineProperty(exports, "UsageService", { enumerable: true, get: function () { return usage_service_1.UsageService; } });
+var plan_service_1 = require("../services/plan.service");
+Object.defineProperty(exports, "PlanService", { enumerable: true, get: function () { return plan_service_1.PlanService; } });
+var billing_service_1 = require("../services/billing.service");
+Object.defineProperty(exports, "BillingService", { enumerable: true, get: function () { return billing_service_1.BillingService; } });
+var tenant_billing_service_1 = require("../services/tenant-billing.service");
+Object.defineProperty(exports, "TenantBillingService", { enumerable: true, get: function () { return tenant_billing_service_1.TenantBillingService; } });

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const AGENT_FORGE_CONFIG = "AGENT_FORGE_CONFIG";
+export declare const AGENT_QUEUE_NAME = "agentforge:agent-jobs";
+export declare const CURRENT_USER = "CURRENT_USER";

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_USER = exports.AGENT_QUEUE_NAME = exports.AGENT_FORGE_CONFIG = void 0;
+// Use string tokens (not Symbols) so they're compatible with NestJS string-based
+// DI providers and survive cross-package boundaries without instance mismatch.
+exports.AGENT_FORGE_CONFIG = 'AGENT_FORGE_CONFIG';
+exports.AGENT_QUEUE_NAME = 'agentforge:agent-jobs';
+exports.CURRENT_USER = 'CURRENT_USER';

package/dist/domain/agent.d.ts

@@ -0,0 +1,59 @@
+import type { McpServerConfig } from '../types/config.types';
+/**
+ * Visual customization shared by every embed of an agent — the public widget
+ * (`/widget.js`) and the iframe view both read this. Lives on the agent so a
+ * single edit ripples through every site that's embedded it; per-token
+ * theming is intentionally NOT supported (was a misfeature). All fields
+ * optional — widget falls back to its built-in defaults for anything omitted.
+ */
+export interface AgentAppearance {
+    primaryColor?: string;
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    title?: string;
+    greeting?: string;
+    avatarUrl?: string;
+}
+/**
+ * Persisted agent configuration scoped to a Tenant. Created and edited from
+ * the admin UI; resolved by the SDK at runtime via `(tenantId, slug)`.
+ *
+ * Shape is intentionally a superset of `AgentDefinition` (the in-process
+ * config object used today) plus DB metadata. The orchestrator/runner only
+ * needs the prompt/model/limits/tools — everything else here is for
+ * lifecycle: who created it, when, is it still active.
+ */
+export interface AgentRecord {
+    id: string;
+    /** Owner tenant — every lookup is scoped to this. */
+    tenantId: string;
+    /** Human-friendly identifier the SDK uses, e.g. `support-bot`.
+     *  Unique within a tenant, not globally. */
+    slug: string;
+    name: string;
+    description?: string;
+    /** Claude model id, e.g. `claude-sonnet-4-6`. */
+    model?: string;
+    systemPrompt: string;
+    /** Optional plain-text knowledge prepended to the system prompt at run-time.
+     *  No retrieval — this is the cheap path before RAG. */
+    context?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    /** Tool ids the agent can use. Persisted but not yet exposed in the UI. */
+    tools?: string[];
+    /** MCP servers the agent can connect to. Same caveat as `tools`. */
+    mcpServers?: McpServerConfig[];
+    /** Visual customization for embeds. Single source of truth — applies to
+     *  every chat token issued for this agent. */
+    appearance?: AgentAppearance;
+    /** Soft-delete: keeps history intact while hiding from active use. */
+    isActive: boolean;
+    /** UserId of the platform user who created the agent (audit trail). */
+    createdByUserId?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export type NewAgentRecord = Pick<AgentRecord, 'id' | 'tenantId' | 'slug' | 'name' | 'systemPrompt'> & Partial<Omit<AgentRecord, 'id' | 'tenantId' | 'slug' | 'name' | 'systemPrompt' | 'createdAt' | 'updatedAt'>>;
+export type AgentRecordPatch = Partial<Omit<AgentRecord, 'id' | 'tenantId' | 'createdAt' | 'updatedAt'>>;

package/dist/domain/agent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domain/api-key.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Long-lived secret a tenant uses to authenticate machine-to-machine. Format:
+ *   ak_live_<48 hex chars>     (192 bits of entropy)
+ *
+ * The full key is shown to the user ONLY at creation time. We store the
+ * sha256 hash. The first 16 chars (`ak_live_a1b2c3d4`) are kept in plaintext
+ * as a `keyPrefix` so users can identify which key in their dashboard.
+ *
+ * The `ak_live_` prefix is intentional — GitHub secret-scanning, Datadog and
+ * similar tools detect leaked credentials by prefix.
+ */
+export interface ApiKey {
+    id: string;
+    tenantId: string;
+    /** When set, the key only authorizes calls to this specific agent. NULL
+     *  means tenant-wide — any agent in the tenant resolves. */
+    agentId?: string;
+    name: string;
+    keyHash: string;
+    keyPrefix: string;
+    scopes?: string[];
+    expiresAt?: Date;
+    revokedAt?: Date;
+    lastUsedAt?: Date;
+    createdAt: Date;
+}
+export type NewApiKey = Omit<ApiKey, 'id' | 'createdAt' | 'lastUsedAt'>;
+export type ApiKeyPatch = Partial<Pick<ApiKey, 'lastUsedAt' | 'revokedAt' | 'expiresAt' | 'name'>>;

package/dist/domain/api-key.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/domain/auth-identity.d.ts

@@ -0,0 +1,10 @@
+export interface AuthIdentity {
+    id: string;
+    userId: string;
+    provider: string;
+    providerId: string;
+    email?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+export type NewAuthIdentity = Omit<AuthIdentity, 'id' | 'createdAt'>;

package/dist/domain/auth-identity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });