@agentforge-io/core 0.2.0

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+// ─── Public API of @agentforge-io/core ─────────────────────────────────────────
+//
+// AI-runtime SDK. After Phase 3 the lib is responsible only for:
+//   - Agent loop (Anthropic / future LLM adapters)
+//   - Conversation + message persistence contract
+//   - Tool registry + execution
+//   - Prepared streaming
+//   - Background agent-job queue
+//   - SdkHooks for host observability
+//
+// Identity, multi-tenancy, billing, infra (email/upload/secrets) all live
+// in the host's own modules. The SDK exposes opaque `userId`, `tenantId`
+// strings; the host validates and enriches them.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentForge = exports.InMemoryJobQueue = exports.JOB_QUEUE = exports.RedisRateLimiter = exports.InMemoryRateLimiter = exports.RATE_LIMITER = exports.PREPARED_STREAM_STORE = 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; } });
+// ─── Types ──────────────────────────────────────────────────────────────────
+__exportStar(require("./types"), exports);
+__exportStar(require("./domain"), exports);
+// ─── Repository contracts ───────────────────────────────────────────────────
+__exportStar(require("./repositories"), exports);
+__exportStar(require("./repositories/in-memory"), exports);
+// ─── Adapter contracts (runtime infra) ──────────────────────────────────────
+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 rate_limiter_types_1 = require("./adapters/rate-limiter/rate-limiter.types");
+Object.defineProperty(exports, "RATE_LIMITER", { enumerable: true, get: function () { return rate_limiter_types_1.RATE_LIMITER; } });
+var in_memory_1 = require("./adapters/rate-limiter/in-memory");
+Object.defineProperty(exports, "InMemoryRateLimiter", { enumerable: true, get: function () { return in_memory_1.InMemoryRateLimiter; } });
+var redis_1 = require("./adapters/rate-limiter/redis");
+Object.defineProperty(exports, "RedisRateLimiter", { enumerable: true, get: function () { return redis_1.RedisRateLimiter; } });
+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_2 = require("./adapters/job-queue/in-memory");
+Object.defineProperty(exports, "InMemoryJobQueue", { enumerable: true, get: function () { return in_memory_2.InMemoryJobQueue; } });
+// ─── Services (framework-free) ──────────────────────────────────────────────
+__exportStar(require("./services"), exports);
+// ─── Container factory ──────────────────────────────────────────────────────
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "createAgentForge", { enumerable: true, get: function () { return factory_1.createAgentForge; } });

package/dist/repositories/in-memory.d.ts

@@ -0,0 +1,30 @@
+import type { ConversationRepository, MessageRepository } from './index';
+import type { Conversation, NewConversation, Message, NewMessage } from '../domain/conversation';
+import type { ConversationStatus } from '../types/agent.types';
+export declare class InMemoryConversationRepository implements ConversationRepository {
+    private byId;
+    create(c: NewConversation): Promise<Conversation>;
+    findById(id: string): Promise<Conversation | null>;
+    findByIdForUser(id: string, userId: string): Promise<Conversation | null>;
+    listForUser(userId: string, opts?: {
+        status?: ConversationStatus;
+        limit?: number;
+        offset?: number;
+    }): Promise<Conversation[]>;
+    updateStats(id: string, patch: {
+        status?: ConversationStatus;
+        addInputTokens?: number;
+        addOutputTokens?: number;
+        addMessages?: number;
+    }): Promise<void>;
+}
+export declare class InMemoryMessageRepository implements MessageRepository {
+    private items;
+    create(m: NewMessage): Promise<Message>;
+    listForConversation(conversationId: string, _userId: string): Promise<Message[]>;
+}
+/** Build a minimal in-memory repo bundle for tests/demos. */
+export declare function createInMemoryRepositories(): {
+    conversations: InMemoryConversationRepository;
+    messages: InMemoryMessageRepository;
+};

package/dist/repositories/in-memory.js

@@ -0,0 +1,82 @@
+"use strict";
+// In-memory repositories for tests + demos. Production should use TypeORM
+// adapters (@agentforge-io/typeorm). After Phase 3, only conversation + message
+// remain — identity / multi-tenant / billing etc. all moved to the host.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryMessageRepository = exports.InMemoryConversationRepository = void 0;
+exports.createInMemoryRepositories = createInMemoryRepositories;
+const crypto_1 = require("crypto");
+class InMemoryConversationRepository {
+    constructor() {
+        this.byId = new Map();
+    }
+    async create(c) {
+        const now = new Date();
+        const full = {
+            id: (0, crypto_1.randomUUID)(),
+            status: 'active',
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            messageCount: 0,
+            createdAt: now,
+            updatedAt: now,
+            ...c,
+        };
+        this.byId.set(full.id, full);
+        return full;
+    }
+    async findById(id) {
+        return this.byId.get(id) ?? null;
+    }
+    async findByIdForUser(id, userId) {
+        const c = this.byId.get(id);
+        return c && c.userId === userId ? c : null;
+    }
+    async listForUser(userId, opts = {}) {
+        let items = Array.from(this.byId.values()).filter((c) => c.userId === userId);
+        if (opts.status)
+            items = items.filter((c) => c.status === opts.status);
+        items.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        const start = opts.offset ?? 0;
+        const end = opts.limit ? start + opts.limit : undefined;
+        return items.slice(start, end);
+    }
+    async updateStats(id, patch) {
+        const c = this.byId.get(id);
+        if (!c)
+            return;
+        if (patch.status !== undefined)
+            c.status = patch.status;
+        if (patch.addInputTokens)
+            c.totalInputTokens += patch.addInputTokens;
+        if (patch.addOutputTokens)
+            c.totalOutputTokens += patch.addOutputTokens;
+        if (patch.addMessages)
+            c.messageCount += patch.addMessages;
+        c.updatedAt = new Date();
+    }
+}
+exports.InMemoryConversationRepository = InMemoryConversationRepository;
+class InMemoryMessageRepository {
+    constructor() {
+        this.items = [];
+    }
+    async create(m) {
+        const full = { id: (0, crypto_1.randomUUID)(), createdAt: new Date(), ...m };
+        this.items.push(full);
+        return full;
+    }
+    async listForConversation(conversationId, _userId) {
+        return this.items
+            .filter((m) => m.conversationId === conversationId)
+            .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    }
+}
+exports.InMemoryMessageRepository = InMemoryMessageRepository;
+/** Build a minimal in-memory repo bundle for tests/demos. */
+function createInMemoryRepositories() {
+    return {
+        conversations: new InMemoryConversationRepository(),
+        messages: new InMemoryMessageRepository(),
+    };
+}

package/dist/repositories/index.d.ts

@@ -0,0 +1,67 @@
+import type { Conversation, NewConversation, Message, NewMessage } from '../domain/conversation';
+import type { ChatToken, NewChatToken, ChatTokenPatch } from '../domain/chat-token';
+import type { McpServerRecord, NewMcpServerRecord, McpServerRecordPatch } from '../domain/mcp-server';
+import type { ConnectorAuth, NewConnectorAuth, ConnectorAuthPatch } from '../domain/connector-auth';
+import type { ConversationStatus } from '../types/agent.types';
+export declare const CONVERSATION_REPOSITORY = "AGENTFORGE_CONVERSATION_REPOSITORY";
+export declare const MESSAGE_REPOSITORY = "AGENTFORGE_MESSAGE_REPOSITORY";
+export declare const CHAT_TOKEN_REPOSITORY = "AGENTFORGE_CHAT_TOKEN_REPOSITORY";
+export declare const MCP_SERVER_REPOSITORY = "AGENTFORGE_MCP_SERVER_REPOSITORY";
+export declare const CONNECTOR_AUTH_REPOSITORY = "AGENTFORGE_CONNECTOR_AUTH_REPOSITORY";
+export interface ConversationRepository {
+    create(conv: NewConversation): Promise<Conversation>;
+    findById(id: string): Promise<Conversation | null>;
+    /** Same as findById but also enforces ownership — used in user-scoped routes. */
+    findByIdForUser(id: string, userId: string): Promise<Conversation | null>;
+    /**
+     * List the user's conversations, newest first. `userId` is opaque — the
+     * SDK never validates it; the host's JWT guard does.
+     */
+    listForUser(userId: string, opts?: {
+        status?: ConversationStatus;
+        limit?: number;
+        offset?: number;
+    }): Promise<Conversation[]>;
+    updateStats(id: string, patch: {
+        status?: ConversationStatus;
+        addInputTokens?: number;
+        addOutputTokens?: number;
+        addMessages?: number;
+    }): Promise<void>;
+}
+export interface MessageRepository {
+    create(message: NewMessage): Promise<Message>;
+    listForConversation(conversationId: string, userId: string): Promise<Message[]>;
+}
+export interface ChatTokenRepository {
+    create(token: NewChatToken): Promise<ChatToken>;
+    /** Hot path — every public widget request looks the token up by string. */
+    findByToken(token: string): Promise<ChatToken | null>;
+    listForAgent(tenantId: string, agentId: string): Promise<ChatToken[]>;
+    update(token: string, patch: ChatTokenPatch): Promise<void>;
+    /** Soft-revoke. */
+    deactivate(token: string): Promise<void>;
+    /** Updates last_used_at — called on every public hit. */
+    touch(token: string, at?: Date): Promise<void>;
+}
+export interface McpServerRepository {
+    create(record: NewMcpServerRecord): Promise<McpServerRecord>;
+    findById(id: string): Promise<McpServerRecord | null>;
+    /** All servers for a tenant, including inactive ones (admin UI shows both). */
+    listForTenant(tenantId: string): Promise<McpServerRecord[]>;
+    /** All active servers across all tenants — used at boot to register
+     *  connections. The host can pass `tenantId` to scope to a single tenant. */
+    listActive(tenantId?: string): Promise<McpServerRecord[]>;
+    update(id: string, patch: McpServerRecordPatch): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export interface ConnectorAuthRepository {
+    create(record: NewConnectorAuth): Promise<ConnectorAuth>;
+    /** Hot path — every tool call resolves the user's token here. */
+    findByUserAndConnector(userId: string, connectorId: string): Promise<ConnectorAuth | null>;
+    /** All connectors a user has authorized — for the Directory UI. */
+    listForUser(userId: string): Promise<ConnectorAuth[]>;
+    update(id: string, patch: ConnectorAuthPatch): Promise<void>;
+    /** Hard delete on revoke. The user can re-auth fresh if they want back in. */
+    delete(id: string): Promise<void>;
+}

package/dist/repositories/index.js

@@ -0,0 +1,16 @@
+"use strict";
+// ─── Repository contracts (AI runtime only) ───────────────────────────────
+// Plain interfaces over conversation + message persistence. Implementations
+// live in framework adapters (TypeORM in @agentforge-io/typeorm, but consumers
+// can plug in Drizzle/Prisma/anything).
+//
+// Identity, multi-tenancy, billing, infra all moved out of the SDK. The host
+// provides those concerns as its own modules.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONNECTOR_AUTH_REPOSITORY = exports.MCP_SERVER_REPOSITORY = exports.CHAT_TOKEN_REPOSITORY = exports.MESSAGE_REPOSITORY = exports.CONVERSATION_REPOSITORY = void 0;
+// ─── Tokens ────────────────────────────────────────────────────────────────
+exports.CONVERSATION_REPOSITORY = 'AGENTFORGE_CONVERSATION_REPOSITORY';
+exports.MESSAGE_REPOSITORY = 'AGENTFORGE_MESSAGE_REPOSITORY';
+exports.CHAT_TOKEN_REPOSITORY = 'AGENTFORGE_CHAT_TOKEN_REPOSITORY';
+exports.MCP_SERVER_REPOSITORY = 'AGENTFORGE_MCP_SERVER_REPOSITORY';
+exports.CONNECTOR_AUTH_REPOSITORY = 'AGENTFORGE_CONNECTOR_AUTH_REPOSITORY';

package/dist/services/agent-config.service.d.ts

@@ -0,0 +1,45 @@
+import type { AgentConfigRepository, AgentConfigListOptions, AgentConfigListResult } from '../repositories';
+import type { AgentRecord, AgentRecordPatch } from '../domain/agent';
+export declare class AgentConfigError extends Error {
+    status: number;
+    code: 'not_found' | 'duplicate_slug' | 'invalid' | 'forbidden';
+    constructor(code: AgentConfigError['code'], message: string);
+}
+export interface AgentConfigCreateInput {
+    tenantId: string;
+    slug: string;
+    name: string;
+    systemPrompt: string;
+    description?: string;
+    model?: string;
+    context?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    tools?: string[];
+    isActive?: boolean;
+    createdByUserId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Application-level CRUD for per-tenant agent configurations. Controllers
+ * call this — they do NOT touch the repository directly so we can keep
+ * validation (slug format, unique-per-tenant) in one place.
+ */
+export declare class AgentConfigService {
+    private readonly repo;
+    constructor(repo: AgentConfigRepository);
+    create(input: AgentConfigCreateInput): Promise<AgentRecord>;
+    getById(id: string): Promise<AgentRecord>;
+    /**
+     * Confirms the agent belongs to `tenantId`. Used by admin endpoints so a
+     * tenant can't fetch another tenant's agent by guessing the id.
+     */
+    getByIdForTenant(id: string, tenantId: string): Promise<AgentRecord>;
+    /** SDK hot path. Returns null on miss — callers decide whether to 404 or
+     *  fall back to the legacy hardcoded array. */
+    findBySlug(tenantId: string, slug: string): Promise<AgentRecord | null>;
+    listForTenant(tenantId: string, opts?: AgentConfigListOptions): Promise<AgentConfigListResult>;
+    update(id: string, tenantId: string, patch: AgentRecordPatch): Promise<AgentRecord>;
+    deactivate(id: string, tenantId: string): Promise<void>;
+}

package/dist/services/agent-config.service.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentConfigService = exports.AgentConfigError = void 0;
+const crypto_1 = require("crypto");
+class AgentConfigError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.status =
+            code === 'forbidden'
+                ? 403
+                : code === 'not_found'
+                    ? 404
+                    : code === 'duplicate_slug'
+                        ? 409
+                        : 400;
+    }
+}
+exports.AgentConfigError = AgentConfigError;
+// Slug rules are deliberately strict so they're URL-safe and predictable for
+// SDK callers: lowercase letters, digits, hyphen, underscore. Length 2..64.
+const SLUG_RE = /^[a-z0-9][a-z0-9_-]{1,62}[a-z0-9]$/;
+/**
+ * Application-level CRUD for per-tenant agent configurations. Controllers
+ * call this — they do NOT touch the repository directly so we can keep
+ * validation (slug format, unique-per-tenant) in one place.
+ */
+class AgentConfigService {
+    constructor(repo) {
+        this.repo = repo;
+    }
+    async create(input) {
+        if (!input.tenantId)
+            throw new AgentConfigError('invalid', 'tenantId is required');
+        if (!input.name?.trim())
+            throw new AgentConfigError('invalid', 'name is required');
+        if (!input.systemPrompt?.trim())
+            throw new AgentConfigError('invalid', 'systemPrompt is required');
+        const slug = input.slug.trim().toLowerCase();
+        if (!SLUG_RE.test(slug)) {
+            throw new AgentConfigError('invalid', 'slug must be 3–64 chars, lowercase letters/digits/hyphen/underscore, start and end alphanumeric');
+        }
+        const existing = await this.repo.findBySlug(input.tenantId, slug);
+        if (existing) {
+            throw new AgentConfigError('duplicate_slug', `An agent with slug "${slug}" already exists for this tenant.`);
+        }
+        const record = {
+            id: (0, crypto_1.randomUUID)(),
+            tenantId: input.tenantId,
+            slug,
+            name: input.name.trim(),
+            systemPrompt: input.systemPrompt,
+            description: input.description?.trim(),
+            model: input.model,
+            context: input.context,
+            temperature: input.temperature,
+            topP: input.topP,
+            maxTokens: input.maxTokens,
+            tools: input.tools,
+            isActive: input.isActive ?? true,
+            createdByUserId: input.createdByUserId,
+            metadata: input.metadata,
+        };
+        return this.repo.create(record);
+    }
+    async getById(id) {
+        const a = await this.repo.findById(id);
+        if (!a)
+            throw new AgentConfigError('not_found', 'Agent not found');
+        return a;
+    }
+    /**
+     * Confirms the agent belongs to `tenantId`. Used by admin endpoints so a
+     * tenant can't fetch another tenant's agent by guessing the id.
+     */
+    async getByIdForTenant(id, tenantId) {
+        const a = await this.getById(id);
+        if (a.tenantId !== tenantId) {
+            // Don't reveal existence — return not_found.
+            throw new AgentConfigError('not_found', 'Agent not found');
+        }
+        return a;
+    }
+    /** SDK hot path. Returns null on miss — callers decide whether to 404 or
+     *  fall back to the legacy hardcoded array. */
+    async findBySlug(tenantId, slug) {
+        return this.repo.findBySlug(tenantId, slug.toLowerCase());
+    }
+    async listForTenant(tenantId, opts = {}) {
+        return this.repo.listForTenant(tenantId, opts);
+    }
+    async update(id, tenantId, patch) {
+        const current = await this.getByIdForTenant(id, tenantId);
+        // Slug changes need re-validation + uniqueness check.
+        if (patch.slug !== undefined && patch.slug !== current.slug) {
+            const nextSlug = patch.slug.trim().toLowerCase();
+            if (!SLUG_RE.test(nextSlug)) {
+                throw new AgentConfigError('invalid', 'slug must be 3–64 chars, lowercase letters/digits/hyphen/underscore');
+            }
+            const dup = await this.repo.findBySlug(tenantId, nextSlug);
+            if (dup && dup.id !== id) {
+                throw new AgentConfigError('duplicate_slug', `An agent with slug "${nextSlug}" already exists for this tenant.`);
+            }
+            patch.slug = nextSlug;
+        }
+        await this.repo.update(id, patch);
+        return this.getById(id);
+    }
+    async deactivate(id, tenantId) {
+        await this.getByIdForTenant(id, tenantId);
+        await this.repo.deactivate(id);
+    }
+}
+exports.AgentConfigService = AgentConfigService;

package/dist/services/agent-job.worker.d.ts

@@ -0,0 +1,32 @@
+import type { AgentJobPayload, AgentJobResult } from '../types/agent.types';
+import type { JobContext } from '../adapters/job-queue/job-queue.types';
+import type { SdkHooks } from '../types/hooks';
+import type { OrchestratorService } from './orchestrator.service';
+import type { ConversationService } from './conversation.service';
+import type { Logger } from './tool-registry.service';
+/**
+ * Framework-free worker for the `agent-turn` job kind. Both the Nest BullMQ
+ * processor and any in-memory JobQueue (Express adapter, custom integrations)
+ * delegate to `process(payload)` here — the transport decides how a payload
+ * is delivered, this class owns what happens with one.
+ *
+ * Side effects, in order:
+ *   1. Run the orchestrator for `agentId` with the supplied messages.
+ *   2. Persist the assistant message via ConversationService.
+ *   3. Emit `onUsage` + `onTurnComplete` hooks for the host to handle.
+ *
+ * Progress is reported through the JobContext when provided (10% before the
+ * run, 70% after persistence, 100% on return). Callers without a queue can
+ * call `process(payload)` with no context.
+ */
+export declare class AgentJobWorker {
+    private readonly orchestrator;
+    private readonly conversations;
+    private readonly logger;
+    private readonly hooks?;
+    constructor(orchestrator: OrchestratorService, conversations: ConversationService, opts?: {
+        logger?: Logger;
+        hooks?: SdkHooks;
+    });
+    process(payload: AgentJobPayload, ctx?: JobContext): Promise<AgentJobResult>;
+}

package/dist/services/agent-job.worker.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentJobWorker = void 0;
+const noopLogger = {
+    log: () => { }, warn: () => { }, debug: () => { }, error: () => { },
+};
+/**
+ * Framework-free worker for the `agent-turn` job kind. Both the Nest BullMQ
+ * processor and any in-memory JobQueue (Express adapter, custom integrations)
+ * delegate to `process(payload)` here — the transport decides how a payload
+ * is delivered, this class owns what happens with one.
+ *
+ * Side effects, in order:
+ *   1. Run the orchestrator for `agentId` with the supplied messages.
+ *   2. Persist the assistant message via ConversationService.
+ *   3. Emit `onUsage` + `onTurnComplete` hooks for the host to handle.
+ *
+ * Progress is reported through the JobContext when provided (10% before the
+ * run, 70% after persistence, 100% on return). Callers without a queue can
+ * call `process(payload)` with no context.
+ */
+class AgentJobWorker {
+    constructor(orchestrator, conversations, opts = {}) {
+        this.orchestrator = orchestrator;
+        this.conversations = conversations;
+        this.logger = opts.logger ?? noopLogger;
+        this.hooks = opts.hooks;
+    }
+    async process(payload, ctx) {
+        const { jobId, userId, conversationId, agentId, messages } = payload;
+        this.logger.log(`Processing agent job ${jobId} for user ${userId}`);
+        await ctx?.updateProgress(10);
+        const response = await this.orchestrator.run(agentId, messages, {
+            userId,
+            conversationId,
+            agentId,
+            messageId: jobId,
+        });
+        await ctx?.updateProgress(70);
+        await this.conversations.addMessage({
+            conversationId,
+            userId,
+            role: 'assistant',
+            content: response.content,
+            toolCalls: response.toolCalls,
+            usage: response.usage,
+        });
+        if (this.hooks?.onUsage || this.hooks?.onTurnComplete) {
+            const now = new Date();
+            if (this.hooks.onUsage) {
+                try {
+                    await this.hooks.onUsage({
+                        version: 1,
+                        turnId: response.messageId,
+                        conversationId,
+                        agentId,
+                        userId,
+                        provider: 'anthropic',
+                        modelId: 'unknown',
+                        inputTokens: response.usage.inputTokens,
+                        outputTokens: response.usage.outputTokens,
+                        durationMs: 0,
+                        at: now,
+                    });
+                }
+                catch (err) {
+                    this.logger.warn(`[agentforge] onUsage hook threw: ${String(err)}`);
+                }
+            }
+            if (this.hooks.onTurnComplete) {
+                try {
+                    await this.hooks.onTurnComplete({
+                        version: 1,
+                        turnId: response.messageId,
+                        conversationId,
+                        agentId,
+                        userId,
+                        status: 'ok',
+                        toolCallCount: response.toolCalls?.length ?? 0,
+                        durationMs: 0,
+                        at: now,
+                    });
+                }
+                catch (err) {
+                    this.logger.warn(`[agentforge] onTurnComplete hook threw: ${String(err)}`);
+                }
+            }
+        }
+        await ctx?.updateProgress(100);
+        return {
+            jobId,
+            response,
+            completedAt: new Date(),
+        };
+    }
+}
+exports.AgentJobWorker = AgentJobWorker;

package/dist/services/agent-runner.service.d.ts

@@ -0,0 +1,35 @@
+import type { AgentOverrides, AgentResponse, AnthropicMessage, StreamChunk, ToolExecutionContext } from '../types/agent.types';
+import type { AgentDefinition, AnthropicConfig } from '../types/config.types';
+import type { ToolRegistryService } from './tool-registry.service';
+import type { Logger } from './tool-registry.service';
+/**
+ * Framework-free runner for Claude. Handles the agentic loop (tool calls) for
+ * sync runs and exposes streaming as an `AsyncGenerator<StreamChunk>` so any
+ * transport (SSE, fetch+ReadableStream, WebSocket, etc.) can consume it.
+ */
+export declare class AgentRunnerService {
+    private readonly anthropicConfig;
+    private readonly toolRegistry;
+    private readonly client;
+    private readonly logger;
+    constructor(anthropicConfig: AnthropicConfig, toolRegistry: ToolRegistryService, opts?: {
+        logger?: Logger;
+    });
+    run(agent: AgentDefinition, messages: AnthropicMessage[], context: ToolExecutionContext, overrides?: AgentOverrides): Promise<AgentResponse>;
+    stream(agent: AgentDefinition, messages: AnthropicMessage[], context: ToolExecutionContext, overrides?: AgentOverrides): AsyncGenerator<StreamChunk>;
+    /**
+     * Merge `agent.tools[]` (resolved via the global registry) with any
+     * per-call extras (e.g. the user's connector tools).
+     *
+     * Returns:
+     *   - `tools`: the Anthropic-shaped array sent to the LLM
+     *   - `extras`: a name→definition map so `dispatchTool` can route execution
+     *     for tools that aren't in the global registry
+     *
+     * Extras with the same name as a global tool shadow the global one — useful
+     * when a connector wants to override the built-in `http_request`, for
+     * example. The shadowing only lasts for this call.
+     */
+    private buildToolList;
+    private dispatchTool;
+}