@roj-ai/sdk 0.0.2

package/dist/bootstrap.d.ts

@@ -0,0 +1,453 @@
+/**
+ * Bootstrap - Composition Root for Agent Server
+ *
+ * Creates and wires all services together based on configuration.
+ */
+import type { EventStore } from './core/events/event-store.js';
+import type { FileStore } from './core/file-store/types.js';
+import { LLMLogger } from './core/llm/index.js';
+import type { LLMProvider } from './core/llm/provider.js';
+import type { Preset } from './core/preset/index.js';
+import type { Platform } from './platform/index.js';
+import { PreprocessorRegistry } from './plugins/uploads/preprocessor.js';
+import type { Config } from './config.js';
+import type { SessionManager } from './core/sessions/session-manager.js';
+import type { UserOutputCallback } from './core/sessions/session.js';
+import { type AllMethodSchemas, type System } from './core/system.js';
+import type { ToolExecutor } from './core/tools/executor.js';
+import type { Logger } from './lib/logger/logger.js';
+import { PortPool } from './plugins/services/port-pool.js';
+import type { RojConfig } from './user-config.js';
+/**
+ * All built-in plugin definitions passed to createSystem for type inference.
+ * These are always registered in every session (see SessionManager.createSessionInstance).
+ */
+declare const builtinPlugins: readonly [import("./index.js").PluginDefinition<"sessions", void, void, Record<"create", {
+    input: {
+        presetId: string;
+        workspaceDir?: string | undefined;
+        sessionId?: string | undefined;
+    };
+    output: {
+        sessionId: string & import("zod").$brand<"SessionId">;
+    };
+}> & Record<"list", {
+    input: {
+        status?: "active" | "closed" | "errored" | undefined;
+        tags?: string[] | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        orderBy?: "createdAt" | "lastActivityAt" | undefined;
+        order?: "asc" | "desc" | undefined;
+    };
+    output: {
+        sessions: unknown[];
+        total: number;
+    };
+}> & Record<"fork", {
+    input: {
+        sessionId: string & import("zod").$brand<"SessionId">;
+        eventIndex: number;
+    };
+    output: {
+        sessionId: string & import("zod").$brand<"SessionId">;
+    };
+}>, Record<"get", {
+    input: Record<string, never>;
+    output: {
+        sessionId: string & import("zod").$brand<"SessionId">;
+        presetId: string;
+        status: string;
+        createdAt: number;
+        agentCount: number;
+        entryAgentId: (string & import("zod").$brand<"AgentId">) | null;
+        closedAt?: number | undefined;
+    };
+}> & Record<"close", {
+    input: Record<string, never>;
+    output: {};
+}> & Record<"reopen", {
+    input: Record<string, never>;
+    output: {};
+}> & Record<"updateMetadata", {
+    input: {
+        name?: string | undefined;
+    };
+    output: {};
+}> & Record<"getEvents", {
+    input: {
+        since?: number | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        type?: string | undefined;
+        agentId?: string | undefined;
+    };
+    output: {
+        events: unknown[];
+        total: number;
+        lastIndex: number;
+    };
+}>>, import("./index.js").PluginDefinition<"presets", void, void, Record<"list", {
+    input: Record<string, never>;
+    output: {
+        presets: {
+            id: string;
+            name: string;
+            description?: string;
+            defaultResourceSlugs?: string[];
+        }[];
+    };
+}> & Record<"getAgents", {
+    input: {
+        sessionId: string & import("zod").$brand<"SessionId">;
+    };
+    output: {
+        agents: {
+            name: string;
+            spawnableBy: string[];
+            hasInputSchema: boolean;
+        }[];
+    };
+}>, {}>, import("./index.js").PluginDefinition<"mailbox", import("./index.js").MailboxPresetConfig, import("./index.js").MailboxAgentConfig, {}, Record<"send", {
+    input: {
+        toAgentId: string & import("zod").$brand<"AgentId">;
+        content: string;
+        fromAgentId?: (string & import("zod").$brand<"AgentId">) | undefined;
+        debug?: boolean | undefined;
+    };
+    output: {
+        messageId: string;
+    };
+}>>, import("./index.js").PluginDefinition<"agents", import("./index.js").AgentsPluginConfig, void, {}, Record<"spawn", {
+    input: {
+        definitionName: string;
+        parentId: string & import("zod").$brand<"AgentId">;
+        message?: string | undefined;
+        typedInput?: unknown;
+    };
+    output: {
+        agentId: string & import("zod").$brand<"AgentId">;
+    };
+}> & Record<"resume", {
+    input: {
+        agentId: string & import("zod").$brand<"AgentId">;
+    };
+    output: {};
+}> & Record<"pause", {
+    input: {
+        agentId: string & import("zod").$brand<"AgentId">;
+        message?: string | undefined;
+    };
+    output: {};
+}> & Record<"rewind", {
+    input: {
+        agentId: string & import("zod").$brand<"AgentId">;
+        messageIndex: number;
+    };
+    output: {};
+}>>, import("./index.js").PluginDefinition<"agent-status", void, void, {}, {}>, import("./index.js").PluginDefinition<"user-chat", import("./index.js").UserChatPresetConfig, import("./index.js").UserChatAgentConfig, {}, Record<"askQuestion", {
+    input: {
+        agentId: string & import("zod").$brand<"AgentId">;
+        question: string;
+        inputType: {
+            type: "text";
+            placeholder?: string | undefined;
+            multiline?: boolean | undefined;
+        } | {
+            type: "single_choice";
+            options: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[];
+        } | {
+            type: "multi_choice";
+            options: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[];
+            minSelect?: number | undefined;
+            maxSelect?: number | undefined;
+        } | {
+            type: "rating";
+            min: number;
+            max: number;
+            labels?: {
+                min?: string | undefined;
+                max?: string | undefined;
+            } | undefined;
+        } | {
+            type: "confirm";
+            confirmLabel?: string | undefined;
+            cancelLabel?: string | undefined;
+        };
+    };
+    output: {
+        messageId: string;
+    };
+}> & Record<"tellUser", {
+    input: {
+        agentId: string & import("zod").$brand<"AgentId">;
+        message: string;
+        format: "text" | "markdown";
+    };
+    output: {
+        messageId: string;
+    };
+}> & Record<"sendMessage", {
+    input: {
+        content: string;
+        agentId?: (string & import("zod").$brand<"AgentId">) | undefined;
+    };
+    output: {
+        messageId: string & import("zod").$brand<"ChatMessageId">;
+    };
+}> & Record<"answerQuestion", {
+    input: {
+        agentId: string & import("zod").$brand<"AgentId">;
+        questionId: string & import("zod").$brand<"ChatMessageId">;
+        answer: unknown;
+    };
+    output: {};
+}> & Record<"getMessages", {
+    input: {
+        sessionId: string;
+    };
+    output: {
+        messages: unknown[];
+    };
+}>>, import("./index.js").PluginDefinition<"uploads", import("./plugins/uploads/plugin.js").UploadsPluginConfig, void, {}, Record<"listPending", {
+    input: {
+        sessionId: string;
+    };
+    output: {
+        uploads: {
+            uploadId: string;
+            filename: string;
+            mimeType: string;
+            size: number;
+            status: "processing" | "ready" | "failed";
+            createdAt: number;
+        }[];
+    };
+}> & Record<"delete", {
+    input: {
+        sessionId: string;
+        uploadId: string;
+    };
+    output: {};
+}> & Record<"loadAttachments", {
+    input: {
+        sessionId: string;
+        uploadIds: string[];
+    };
+    output: {
+        attachments: unknown[];
+    };
+}> & Record<"markUsed", {
+    input: {
+        sessionId: string;
+        uploadIds: string[];
+        messageId: string;
+    };
+    output: {};
+}> & Record<"upload", {
+    input: {
+        sessionId: string;
+        filename: string;
+        mimeType: string;
+        size: number;
+        fileBuffer: Buffer<ArrayBufferLike>;
+    };
+    output: {
+        uploadId: string;
+        status: "ready" | "failed";
+        extractedContent?: string | undefined;
+    };
+}>>, import("./index.js").PluginDefinition<"resources", import("./index.js").ResourcesPluginConfig, void, {}, Record<"inject", {
+    input: {
+        sessionId: string;
+        filename: string;
+        mimeType: string;
+        size: number;
+        fileBuffer: Buffer<ArrayBufferLike>;
+        metadata?: {
+            slug?: string | undefined;
+            name?: string | undefined;
+        } | undefined;
+    };
+    output: {
+        resourceId: string;
+        paths: string[];
+    };
+}>>, import("./index.js").PluginDefinition<"llm", void, void, {}, Record<"getCalls", {
+    input: {
+        limit?: number | undefined;
+        offset?: number | undefined;
+    };
+    output: {
+        calls: unknown[];
+        total: number;
+    };
+}> & Record<"getCall", {
+    input: {
+        callId: string;
+    };
+    output: unknown;
+}> & Record<"getCurlCommand", {
+    input: {
+        callId: string;
+    };
+    output: {
+        curl: string;
+    };
+}>>, import("./index.js").PluginDefinition<"services", import("./plugins/services/plugin.js").ServicePluginConfig, import("./index.js").ServiceAgentConfig, {}, Record<"start", {
+    input: {
+        serviceType?: string | undefined;
+        all?: boolean | undefined;
+        waitForReady?: boolean | undefined;
+    };
+    output: {
+        started?: string[] | undefined;
+    };
+}> & Record<"stop", {
+    input: {
+        serviceType: string;
+    };
+    output: {};
+}> & Record<"restart", {
+    input: {
+        serviceType: string;
+    };
+    output: {};
+}> & Record<"list", {
+    input: Record<string, never>;
+    output: {
+        services: {
+            serviceType: string;
+            status: string;
+            port?: number | undefined;
+        }[];
+    };
+}> & Record<"status", {
+    input: {
+        serviceType: string;
+        logLines?: number | undefined;
+    };
+    output: {
+        serviceType: string;
+        status: string;
+        recentLogs: string[];
+        port?: number | undefined;
+        error?: string | undefined;
+    };
+}> & Record<"logs", {
+    input: {
+        serviceType: string;
+        lines?: number | undefined;
+    };
+    output: {
+        serviceType: string;
+        lines: string[];
+    };
+}>>, import("./index.js").PluginDefinition<"filesystem", import("./plugins/filesystem/plugin.js").FilesystemPresetConfig, import("./plugins/filesystem/plugin.js").FilesystemAgentConfig, {}, Record<"listSession", {
+    input: {
+        path?: string | undefined;
+    };
+    output: {
+        entries: import("./plugins/filesystem/listing.js").DirectoryEntry[];
+        path: string;
+        root: string;
+    };
+}> & Record<"listWorkspace", {
+    input: {
+        path?: string | undefined;
+        recursive?: boolean | undefined;
+    };
+    output: {
+        entries: import("./plugins/filesystem/listing.js").DirectoryEntry[];
+        path: string;
+        root: string;
+    };
+}>>, import("./index.js").PluginDefinition<"logs", void, void, {}, Record<"tail", {
+    input: {
+        since?: number | undefined;
+    };
+    output: {
+        lines: string[];
+        offset: number;
+    };
+}>>, import("./index.js").PluginDefinition<"session-stats", void, void, {}, {}>, import("./index.js").PluginDefinition<"sessionState", import("./index.js").SessionStatePluginConfig, void, {}, Record<"get", {
+    input: {
+        sessionId: string;
+    };
+    output: {
+        state: Record<string, unknown>;
+    };
+}> & Record<"update", {
+    input: {
+        sessionId: string;
+        updates: Record<string, unknown>;
+    };
+    output: {
+        state: {
+            [x: string]: unknown;
+        };
+    };
+}>>, import("./index.js").PluginDefinition<"git-status", void, void, {}, {}>];
+/** Method schemas inferred from all built-in plugins */
+export type BuiltinMethodSchemas = AllMethodSchemas<typeof builtinPlugins>;
+/**
+ * Container for all bootstrapped services
+ */
+export interface Services {
+    eventStore: EventStore;
+    llmProvider: LLMProvider;
+    /** Named provider instances for middleware routing (e.g. useProvider('anthropic')) */
+    llmProviders: ReadonlyMap<string, LLMProvider>;
+    llmLogger?: LLMLogger;
+    toolExecutor: ToolExecutor;
+    logger: Logger;
+    presets: Map<string, Preset>;
+    /** FileStore rooted at dataPath for upload/infrastructure file operations */
+    dataFileStore: FileStore;
+    /** Configuration (needed by upload routes) */
+    config: Config;
+    /** Global port pool shared across all sessions */
+    portPool: PortPool;
+    /** Preprocessor registry for upload content extraction */
+    preprocessorRegistry: PreprocessorRegistry;
+    /** Host-environment adapters (filesystem, process). */
+    platform: Platform;
+}
+/**
+ * Bootstrap all services based on configuration.
+ *
+ * `platform` provides runtime adapters (fs, process). Callers pass concrete
+ * impls from their runtime package (e.g. `createBunPlatform()` from
+ * `@roj-ai/sdk/bun-platform`).
+ */
+export declare function bootstrap(config: Config, userConfig: RojConfig, platform: Platform): Services;
+/**
+ * Create a System wired to bootstrapped services.
+ * Returns the full System object with SessionManager, typed method schemas, and lifecycle methods.
+ */
+export declare function createSystemFromServices(services: Services, options?: {
+    onUserOutput?: UserOutputCallback;
+}): System<BuiltinMethodSchemas, typeof builtinPlugins>;
+/**
+ * Create a SessionManager wired to bootstrapped services.
+ * @deprecated Use createSystemFromServices() instead for typed method registry.
+ */
+export declare function createSessionManager(services: Services, options?: {
+    onUserOutput?: UserOutputCallback;
+}): SessionManager;
+export {};
+/**
+ * Bootstrap for testing with memory store and mock LLM.
+ *
+ * @param mockHandler - Optional custom mock handler for LLM responses
+ * @param presets - Optional presets array (defaults to empty)
+ */
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../src/bootstrap.ts"],"names":[],"mappings":"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"}

package/dist/builtin-events.d.ts

@@ -0,0 +1,16 @@
+/**
+ * BuiltinEvent — Union of all built-in plugin event types.
+ *
+ * This type is the client-side equivalent of ProjectionEvent in projections.ts.
+ * Use it to narrow DomainEvent to access event-specific properties after type checks.
+ */
+import type { agentEvents } from './core/agents/state.js';
+import type { contextEvents } from './core/context/state.js';
+import type { FactoryEventType } from './core/events/types.js';
+import type { llmEvents } from './core/llm/state.js';
+import type { sessionEvents } from './core/sessions/state.js';
+import type { toolEvents } from './core/tools/state.js';
+import type { mailboxEvents } from './plugins/mailbox/state.js';
+import type { userChatEvents } from './plugins/user-chat/plugin.js';
+export type BuiltinEvent = FactoryEventType<typeof agentEvents | typeof sessionEvents | typeof toolEvents | typeof llmEvents | typeof contextEvents | typeof mailboxEvents | typeof userChatEvents>;
+//# sourceMappingURL=builtin-events.d.ts.map

package/dist/builtin-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-events.d.ts","sourceRoot":"","sources":["../src/builtin-events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,MAAM,MAAM,YAAY,GAAG,gBAAgB,CACxC,OAAO,WAAW,GAClB,OAAO,aAAa,GACpB,OAAO,UAAU,GACjB,OAAO,SAAS,GAChB,OAAO,aAAa,GACpB,OAAO,aAAa,GACpB,OAAO,cAAc,CACvB,CAAA"}

package/dist/bun-platform/fs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bun/Node FileSystem adapter — thin wrapper over `node:fs/promises`.
+ *
+ * Bun's `node:fs/promises` is a full-fidelity polyfill; this module is thus
+ * identical under Bun and Node runtimes.
+ */
+import type { FileSystem } from '../platform/index.js';
+export declare function createBunFileSystem(): FileSystem;
+//# sourceMappingURL=fs.d.ts.map

package/dist/bun-platform/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/bun-platform/fs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAEtD,wBAAgB,mBAAmB,IAAI,UAAU,CAuChD"}

package/dist/bun-platform/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Bun/Node platform adapter factory.
+ *
+ * Provides concrete implementations of `@roj-ai/sdk`'s Platform interface
+ * using `node:fs/promises`, `node:child_process`, and `node:os`.
+ */
+import type { Platform } from '../platform/index.js';
+import { createBunFileSystem } from './fs.js';
+import { createBunProcessRunner } from './process.js';
+export declare function createBunPlatform(): Platform;
+export { createBunFileSystem, createBunProcessRunner };
+//# sourceMappingURL=index.d.ts.map

package/dist/bun-platform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bun-platform/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAC7C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAErD,wBAAgB,iBAAiB,IAAI,QAAQ,CAM5C;AAED,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,CAAA"}

package/dist/bun-platform/process.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Bun/Node ProcessRunner adapter — thin wrapper over `node:child_process`.
+ */
+import type { ProcessRunner } from '../platform/index.js';
+export declare function createBunProcessRunner(): ProcessRunner;
+//# sourceMappingURL=process.d.ts.map

package/dist/bun-platform/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/bun-platform/process.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAIzD,wBAAgB,sBAAsB,IAAI,aAAa,CActD"}

package/dist/config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Configuration for the Agent Server
+ */
+import type { MockInferenceHandler } from './core/llm/mock.js';
+import type { LogLevel } from './lib/logger/logger.js';
+/**
+ * Server configuration
+ */
+export interface Config {
+    port: number;
+    host: string;
+    dataPath: string;
+    persistence: 'file' | 'memory';
+    openRouterApiKey?: string;
+    anthropicApiKey?: string;
+    defaultModel?: string;
+    llmMock?: MockInferenceHandler;
+    /** Extended thinking token budget (Anthropic only). When set, enables thinking. */
+    thinkingBudget?: number;
+    llmLoggingEnabled?: boolean;
+    logLevel: LogLevel;
+    logFormat: 'console' | 'json';
+    workerUrl?: string;
+    agentToken?: string;
+    wsReconnectBaseDelayMs?: number;
+    wsReconnectMaxDelayMs?: number;
+    wsHeartbeatIntervalMs?: number;
+    wsHandshakeTimeoutMs?: number;
+}
+/**
+ * Load configuration from environment variables.
+ */
+export declare const loadConfig: () => Config;
+/**
+ * Validate configuration and return errors if any.
+ */
+export declare const validateConfig: (config: Config) => string[];
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAEtD;;GAEG;AACH,MAAM,WAAW,MAAM;IAEtB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IAGZ,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAA;IAI9B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,oBAAoB,CAAA;IAC9B,mFAAmF;IACnF,cAAc,CAAC,EAAE,MAAM,CAAA;IAGvB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAG3B,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,SAAS,GAAG,MAAM,CAAA;IAG7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IAGnB,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,QAAO,MAoB7B,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,KAAG,MAAM,EA2BrD,CAAA"}

package/dist/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../src/config.test.ts"],"names":[],"mappings":""}

package/dist/core/agent-loop.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-loop.integration.test.d.ts.map

package/dist/core/agent-loop.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-loop.integration.test.d.ts","sourceRoot":"","sources":["../../src/core/agent-loop.integration.test.ts"],"names":[],"mappings":""}

package/dist/core/agents/agent-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-config.test.d.ts.map

package/dist/core/agents/agent-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-config.test.d.ts","sourceRoot":"","sources":["../../../src/core/agents/agent-config.test.ts"],"names":[],"mappings":""}

package/dist/core/agents/agent-roles.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent role constants.
+ *
+ * These constants define the special agent roles in the system:
+ * - ORCHESTRATOR: The main agent that coordinates work and spawns sub-agents
+ * - COMMUNICATOR: Optional agent that handles user communication in communication-agent mode
+ */
+/** Orchestrator agent role - the main coordinating agent */
+export declare const ORCHESTRATOR_ROLE: "orchestrator";
+/** Communicator agent role - handles user communication */
+export declare const COMMUNICATOR_ROLE: "communicator";
+/** Type for special agent roles */
+export type AgentRole = typeof ORCHESTRATOR_ROLE | typeof COMMUNICATOR_ROLE;
+/**
+ * Prompt-level role classification for system prompt composition.
+ * - 'entry': Orchestrator without communicator (talks to user directly)
+ * - 'orchestrator': Orchestrator with communicator (talks to communicator, not user)
+ * - 'child': Spawned by parent, reports results back
+ * - 'communicator': Handles user communication, relays to orchestrator
+ */
+export type PromptRole = 'entry' | 'orchestrator' | 'child' | 'communicator';
+/**
+ * Determine an agent's prompt role from its state and session context.
+ */
+export declare function getAgentRole(agentState: {
+    definitionName: string;
+    parentId: string | null;
+}, sessionState: {
+    agents: Map<string, {
+        definitionName: string;
+    }>;
+}): PromptRole;
+//# sourceMappingURL=agent-roles.d.ts.map

package/dist/core/agents/agent-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-roles.d.ts","sourceRoot":"","sources":["../../../src/core/agents/agent-roles.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4DAA4D;AAC5D,eAAO,MAAM,iBAAiB,EAAG,cAAuB,CAAA;AAExD,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB,EAAG,cAAuB,CAAA;AAExD,mCAAmC;AACnC,MAAM,MAAM,SAAS,GAAG,OAAO,iBAAiB,GAAG,OAAO,iBAAiB,CAAA;AAE3E;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,cAAc,GAAG,OAAO,GAAG,cAAc,CAAA;AAE5E;;GAEG;AACH,wBAAgB,YAAY,CAC3B,UAAU,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAC/D,YAAY,EAAE;IAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,GAC/D,UAAU,CAQZ"}

package/dist/core/agents/agent-shutdown.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tests for Agent shutdown behavior - verifying that session close
+ * prevents re-scheduling and aborts in-flight work.
+ */
+export {};
+//# sourceMappingURL=agent-shutdown.test.d.ts.map

package/dist/core/agents/agent-shutdown.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-shutdown.test.d.ts","sourceRoot":"","sources":["../../../src/core/agents/agent-shutdown.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}