substrai-agentdeploy 0.4.0

package/dist/agent.d.ts

@@ -0,0 +1,13 @@
+export interface AgentConfig {
+    name: string;
+    model: string;
+    systemPrompt: string;
+    tools: string[];
+    maxIterations: number;
+    timeoutSeconds: number;
+}
+export declare function agent(config: Partial<AgentConfig>): (fn: (msg: string) => string) => {
+    config: Partial<AgentConfig>;
+    fn: (msg: string) => string;
+    invoke: (msg: string) => string;
+};

package/dist/agent.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agent = agent;
+function agent(config) {
+    return (fn) => ({ config, fn, invoke: (msg) => fn(msg) });
+}

package/dist/cost.d.ts

@@ -0,0 +1,15 @@
+export declare class CostEnforcer {
+    private sessionCosts;
+    private dailyCost;
+    private dailyLimit;
+    private sessionLimit;
+    private requestLimit;
+    constructor(dailyLimit?: number, sessionLimit?: number, requestLimit?: number);
+    checkBudget(sessionId: string, estimatedCost: number): {
+        allowed: boolean;
+        reason?: string;
+    };
+    recordCost(sessionId: string, cost: number): void;
+    getDailyCost(): number;
+    getSessionCost(id: string): number;
+}

package/dist/cost.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostEnforcer = void 0;
+class CostEnforcer {
+    constructor(dailyLimit = 100, sessionLimit = 5, requestLimit = 0.5) {
+        this.sessionCosts = new Map();
+        this.dailyCost = 0;
+        this.dailyLimit = dailyLimit;
+        this.sessionLimit = sessionLimit;
+        this.requestLimit = requestLimit;
+    }
+    checkBudget(sessionId, estimatedCost) {
+        if (estimatedCost > this.requestLimit) {
+            return { allowed: false, reason: `Request cost $${estimatedCost} exceeds limit $${this.requestLimit}` };
+        }
+        const sessionCost = this.sessionCosts.get(sessionId) ?? 0;
+        if (sessionCost + estimatedCost > this.sessionLimit) {
+            return { allowed: false, reason: `Session budget exceeded` };
+        }
+        if (this.dailyCost + estimatedCost > this.dailyLimit) {
+            return { allowed: false, reason: `Daily budget exceeded` };
+        }
+        return { allowed: true };
+    }
+    recordCost(sessionId, cost) {
+        this.dailyCost += cost;
+        const current = this.sessionCosts.get(sessionId) ?? 0;
+        this.sessionCosts.set(sessionId, current + cost);
+    }
+    getDailyCost() { return this.dailyCost; }
+    getSessionCost(id) { return this.sessionCosts.get(id) ?? 0; }
+}
+exports.CostEnforcer = CostEnforcer;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { AgentConfig, agent } from "./agent";
+export { Session, SessionManager } from "./session";
+export { ToolRegistry, ToolPermission } from "./tools";
+export { CostEnforcer } from "./cost";
+export { TenantManager } from "./tenants";
+export { VersionManager } from "./versioning";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionManager = exports.TenantManager = exports.CostEnforcer = exports.ToolPermission = exports.ToolRegistry = exports.SessionManager = exports.Session = exports.agent = void 0;
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "agent", { enumerable: true, get: function () { return agent_1.agent; } });
+var session_1 = require("./session");
+Object.defineProperty(exports, "Session", { enumerable: true, get: function () { return session_1.Session; } });
+Object.defineProperty(exports, "SessionManager", { enumerable: true, get: function () { return session_1.SessionManager; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "ToolRegistry", { enumerable: true, get: function () { return tools_1.ToolRegistry; } });
+Object.defineProperty(exports, "ToolPermission", { enumerable: true, get: function () { return tools_1.ToolPermission; } });
+var cost_1 = require("./cost");
+Object.defineProperty(exports, "CostEnforcer", { enumerable: true, get: function () { return cost_1.CostEnforcer; } });
+var tenants_1 = require("./tenants");
+Object.defineProperty(exports, "TenantManager", { enumerable: true, get: function () { return tenants_1.TenantManager; } });
+var versioning_1 = require("./versioning");
+Object.defineProperty(exports, "VersionManager", { enumerable: true, get: function () { return versioning_1.VersionManager; } });

package/dist/session.d.ts

@@ -0,0 +1,22 @@
+export declare class Session {
+    sessionId: string;
+    agentName: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    turnCount: number;
+    constructor(sessionId: string, agentName: string);
+    addMessage(role: string, content: string): void;
+    getHistory(n?: number): Array<{
+        role: string;
+        content: string;
+    }>;
+}
+export declare class SessionManager {
+    private sessions;
+    getOrCreate(id: string, agentName: string): Session;
+    get(id: string): Session | undefined;
+    delete(id: string): void;
+    get count(): number;
+}

package/dist/session.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.Session = void 0;
+class Session {
+    constructor(sessionId, agentName) {
+        this.messages = [];
+        this.turnCount = 0;
+        this.sessionId = sessionId;
+        this.agentName = agentName;
+    }
+    addMessage(role, content) {
+        this.messages.push({ role, content });
+        this.turnCount++;
+    }
+    getHistory(n = 20) {
+        return this.messages.slice(-n);
+    }
+}
+exports.Session = Session;
+class SessionManager {
+    constructor() {
+        this.sessions = new Map();
+    }
+    getOrCreate(id, agentName) {
+        if (!this.sessions.has(id)) {
+            this.sessions.set(id, new Session(id, agentName));
+        }
+        return this.sessions.get(id);
+    }
+    get(id) {
+        return this.sessions.get(id);
+    }
+    delete(id) {
+        this.sessions.delete(id);
+    }
+    get count() { return this.sessions.size; }
+}
+exports.SessionManager = SessionManager;

package/dist/tenants.d.ts

@@ -0,0 +1,16 @@
+export interface TenantConfig {
+    tenantId: string;
+    rateLimit: number;
+    budgetDaily: number;
+    toolsAllowed: string[];
+    toolsDenied: string[];
+}
+export declare class TenantManager {
+    private tenants;
+    constructor();
+    create(config: TenantConfig): void;
+    get(id: string): TenantConfig | undefined;
+    delete(id: string): boolean;
+    list(): TenantConfig[];
+    get count(): number;
+}

package/dist/tenants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantManager = void 0;
+class TenantManager {
+    constructor() {
+        this.tenants = new Map();
+        this.tenants.set("default", { tenantId: "default", rateLimit: 100, budgetDaily: 50, toolsAllowed: ["all"], toolsDenied: [] });
+    }
+    create(config) { this.tenants.set(config.tenantId, config); }
+    get(id) { return this.tenants.get(id); }
+    delete(id) { if (id === "default")
+        return false; return this.tenants.delete(id); }
+    list() { return Array.from(this.tenants.values()); }
+    get count() { return this.tenants.size; }
+}
+exports.TenantManager = TenantManager;

package/dist/tools.d.ts

@@ -0,0 +1,16 @@
+export declare enum ToolPermission {
+    READ = "read",
+    WRITE = "write",
+    ADMIN = "admin"
+}
+export declare class ToolRegistry {
+    private tools;
+    register(name: string, fn: Function): void;
+    execute(name: string, ...args: any[]): {
+        success: boolean;
+        output?: any;
+        error?: string;
+    };
+    isAllowed(name: string, allowed: string[], denied: string[]): boolean;
+    get count(): number;
+}

package/dist/tools.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = exports.ToolPermission = void 0;
+var ToolPermission;
+(function (ToolPermission) {
+    ToolPermission["READ"] = "read";
+    ToolPermission["WRITE"] = "write";
+    ToolPermission["ADMIN"] = "admin";
+})(ToolPermission || (exports.ToolPermission = ToolPermission = {}));
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    register(name, fn) {
+        this.tools.set(name, fn);
+    }
+    execute(name, ...args) {
+        const fn = this.tools.get(name);
+        if (!fn)
+            return { success: false, error: "Not found" };
+        try {
+            return { success: true, output: fn(...args) };
+        }
+        catch (e) {
+            return { success: false, error: e.message };
+        }
+    }
+    isAllowed(name, allowed, denied) {
+        if (denied.includes(name))
+            return false;
+        if (allowed.includes("all"))
+            return true;
+        return allowed.includes(name);
+    }
+    get count() { return this.tools.size; }
+}
+exports.ToolRegistry = ToolRegistry;

package/dist/versioning.d.ts

@@ -0,0 +1,17 @@
+export interface AgentVersion {
+    id: string;
+    status: "active" | "canary" | "retired" | "rolled_back";
+    traffic: number;
+    deployedAt: string;
+}
+export declare class VersionManager {
+    private versions;
+    private activeId;
+    private canaryId;
+    deploy(id: string, traffic?: number): void;
+    startCanary(id: string, traffic?: number): void;
+    promoteCanary(): boolean;
+    rollback(): string | null;
+    getActiveId(): string | null;
+    getCanaryId(): string | null;
+}

package/dist/versioning.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionManager = void 0;
+class VersionManager {
+    constructor() {
+        this.versions = [];
+        this.activeId = null;
+        this.canaryId = null;
+    }
+    deploy(id, traffic = 100) {
+        if (this.activeId) {
+            const current = this.versions.find(v => v.id === this.activeId);
+            if (current) {
+                current.status = "retired";
+                current.traffic = 0;
+            }
+        }
+        this.versions.push({ id, status: "active", traffic, deployedAt: new Date().toISOString() });
+        this.activeId = id;
+    }
+    startCanary(id, traffic = 10) {
+        const active = this.versions.find(v => v.id === this.activeId);
+        if (active) {
+            active.traffic = 100 - traffic;
+        }
+        this.versions.push({ id, status: "canary", traffic, deployedAt: new Date().toISOString() });
+        this.canaryId = id;
+    }
+    promoteCanary() {
+        if (!this.canaryId)
+            return false;
+        const active = this.versions.find(v => v.id === this.activeId);
+        if (active) {
+            active.status = "retired";
+            active.traffic = 0;
+        }
+        const canary = this.versions.find(v => v.id === this.canaryId);
+        if (canary) {
+            canary.status = "active";
+            canary.traffic = 100;
+        }
+        this.activeId = this.canaryId;
+        this.canaryId = null;
+        return true;
+    }
+    rollback() {
+        const retired = this.versions.filter(v => v.status === "retired");
+        if (!retired.length)
+            return null;
+        const prev = retired[retired.length - 1];
+        const curr = this.versions.find(v => v.id === this.activeId);
+        if (curr) {
+            curr.status = "rolled_back";
+            curr.traffic = 0;
+        }
+        prev.status = "active";
+        prev.traffic = 100;
+        this.activeId = prev.id;
+        return prev.id;
+    }
+    getActiveId() { return this.activeId; }
+    getCanaryId() { return this.canaryId; }
+}
+exports.VersionManager = VersionManager;

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "substrai-agentdeploy",
+  "version": "0.4.0",
+  "description": "Zero-to-production AI agent deployment framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist/**/*"],
+  "scripts": { "build": "tsc", "prepublishOnly": "npm run build" },
+  "keywords": ["ai-agent", "deployment", "serverless", "lambda", "llm", "multi-tenancy", "production"],
+  "author": "Gaurav Kumar Sinha <gaurav@substrai.dev>",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "https://github.com/substrai/agentdeploy" },
+  "homepage": "https://github.com/substrai/agentdeploy",
+  "engines": { "node": ">=16.0.0" },
+  "devDependencies": { "typescript": "^5.0.0" }
+}