@prysm-ai/core 0.1.0

package/agent.d.ts

@@ -0,0 +1,13 @@
+import type { AgentConfig, Turn, ChatMessage } from './agent.types.js';
+import type { AgentHooks } from './hooks.js';
+export declare class Agent {
+    private hooks;
+    constructor(_config: AgentConfig, hooks?: AgentHooks);
+    start(): Promise<void>;
+    end(): Promise<void>;
+    runTurn(turn: Turn): Promise<TurnResult>;
+}
+export interface TurnResult {
+    messages: ChatMessage[];
+    interrupted: boolean;
+}

package/agent.js

@@ -0,0 +1,38 @@
+export class Agent {
+    hooks;
+    constructor(_config, hooks) {
+        this.hooks = hooks ?? {};
+    }
+    async start() {
+        if (this.hooks.beforeAgentStart) {
+            await this.hooks.beforeAgentStart();
+        }
+    }
+    async end() {
+        if (this.hooks.afterAgentEnd) {
+            await this.hooks.afterAgentEnd();
+        }
+    }
+    async runTurn(turn) {
+        const { context } = turn;
+        // Before turn hook
+        if (this.hooks.beforeTurn) {
+            const shouldContinue = await this.hooks.beforeTurn(turn, context);
+            if (shouldContinue === false) {
+                this.hooks.beforeTurnSkip?.(turn, context, 'Hook returned false');
+                return { messages: [], interrupted: true };
+            }
+        }
+        try {
+            // Execute turn logic
+            // ... (will be implemented in later phases)
+            return { messages: [], interrupted: false };
+        }
+        catch (error) {
+            if (this.hooks.onTurnError) {
+                await this.hooks.onTurnError(turn, error, context);
+            }
+            throw error;
+        }
+    }
+}

package/agent.types.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+export declare const ChatMessageRoleSchema: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+export type ChatMessageRole = z.infer<typeof ChatMessageRoleSchema>;
+export interface ChatMessage {
+    id: string;
+    role: ChatMessageRole;
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function createChatMessage(role: ChatMessageRole, content: string, options?: Partial<ChatMessage> & {
+    id?: string;
+}): ChatMessage;
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+            additionalProperties?: boolean;
+        };
+    };
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export interface Turn {
+    id: string;
+    messages: ChatMessage[];
+    context: TurnContext;
+}
+export interface TurnContext {
+    tenantId: string | null;
+    userId: string | null;
+    sessionId: string;
+    metadata: Record<string, unknown>;
+    isBatchMode: boolean;
+    batchConfig?: {
+        maxConcurrency: number;
+        onProgress?: (completed: number, total: number) => void;
+    };
+}
+export interface AgentConfig {
+    llm: LLMConfig;
+    tools: ToolDefinition[];
+    maxTurns?: number;
+    timeoutMs?: number;
+}
+export interface LLMConfig {
+    provider: 'openai' | 'anthropic' | 'local';
+    apiKey?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    baseUrl?: string;
+}
+export interface LLMRequestOptions {
+    temperature?: number;
+    maxTokens?: number;
+    stop?: string[];
+    stream?: boolean;
+}
+export interface LLMResponse {
+    content: string;
+    reasoning?: string;
+    finishReason?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export type AgentEvent = {
+    type: 'turn_start';
+    turnId: string;
+    sessionId: string;
+} | {
+    type: 'turn_end';
+    turnId: string;
+    sessionId: string;
+} | {
+    type: 'tool_call_start';
+    toolCall: ToolCall;
+    turnId: string;
+} | {
+    type: 'tool_call_end';
+    toolCall: ToolCall;
+    result: ToolResult;
+    turnId: string;
+};

package/agent.types.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+// Chat Message
+export const ChatMessageRoleSchema = z.enum(['system', 'user', 'assistant', 'tool']);
+export function createChatMessage(role, content, options) {
+    const result = {
+        id: options?.id ?? crypto.randomUUID(),
+        role,
+        content,
+    };
+    if (options?.name !== undefined)
+        result.name = options.name;
+    if (options?.toolCallId !== undefined)
+        result.toolCallId = options.toolCallId;
+    if (options?.metadata !== undefined)
+        result.metadata = options.metadata;
+    return result;
+}

package/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class AgentError extends Error {
+    code: string;
+    statusCode?: number | undefined;
+    context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined, context?: Record<string, unknown> | undefined);
+}
+export declare class LLMError extends AgentError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+export declare class ToolExecutionError extends AgentError {
+    toolName: string;
+    constructor(message: string, toolName: string, context?: Record<string, unknown>);
+}
+export declare class TurnTimeoutError extends AgentError {
+    constructor(sessionId: string, timeoutMs: number);
+}
+export declare class ValidationError extends AgentError {
+    errors?: unknown[] | undefined;
+    constructor(message: string, errors?: unknown[] | undefined);
+}

package/errors.js

@@ -0,0 +1,40 @@
+export class AgentError extends Error {
+    code;
+    statusCode;
+    context;
+    constructor(message, code, statusCode, context) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.context = context;
+        this.name = 'AgentError';
+    }
+}
+export class LLMError extends AgentError {
+    constructor(message, context) {
+        super(message, 'LLM_ERROR', undefined, context);
+        this.name = 'LLMError';
+    }
+}
+export class ToolExecutionError extends AgentError {
+    toolName;
+    constructor(message, toolName, context) {
+        super(message, 'TOOL_EXECUTION_ERROR', undefined, context);
+        this.toolName = toolName;
+        this.name = 'ToolExecutionError';
+    }
+}
+export class TurnTimeoutError extends AgentError {
+    constructor(sessionId, timeoutMs) {
+        super(`Turn timeout after ${timeoutMs}ms`, 'TURN_TIMEOUT', undefined, { sessionId, timeoutMs });
+        this.name = 'TurnTimeoutError';
+    }
+}
+export class ValidationError extends AgentError {
+    errors;
+    constructor(message, errors) {
+        super(message, 'VALIDATION_ERROR', 400, { errors });
+        this.errors = errors;
+        this.name = 'ValidationError';
+    }
+}

package/hooks.d.ts

@@ -0,0 +1,23 @@
+import type { Turn, TurnContext, ToolCall, ToolResult, ChatMessage, LLMRequestOptions, LLMResponse, AgentEvent } from './agent.types.js';
+import type { AgentError } from './errors.js';
+export interface ToolExecutionContext {
+    tenantId: string | null;
+    sessionId: string;
+    turnId: string;
+    toolName: string;
+}
+export interface AgentHooks {
+    beforeAgentStart?(): Promise<void>;
+    afterAgentEnd?(): Promise<void>;
+    beforeTurn?(turn: Turn, context: TurnContext): Promise<void | boolean>;
+    beforeTurnSkip?(turn: Turn, context: TurnContext, reason: string): void;
+    afterTurn?(turn: Turn, context: TurnContext): Promise<void>;
+    onTurnError?(turn: Turn, error: AgentError, context: TurnContext): Promise<void>;
+    beforeToolCall?(toolCall: ToolCall, context: ToolExecutionContext): Promise<void | boolean>;
+    beforeToolCallSkip?(toolCall: ToolCall, context: ToolExecutionContext, reason: string): void;
+    afterToolCall?(toolCall: ToolCall, result: ToolResult, context: ToolExecutionContext): Promise<void>;
+    beforeLLMCall?(messages: ChatMessage[], options: LLMRequestOptions): Promise<void>;
+    afterLLMCall?(response: LLMResponse): Promise<void>;
+    onError?(error: AgentError, context: TurnContext): Promise<void>;
+    onEvent?(event: AgentEvent): Promise<void>;
+}

package/hooks.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from './agent.js';
+export * from './agent.types.js';
+export * from './errors.js';
+export * from './hooks.js';

package/index.js

@@ -0,0 +1,4 @@
+export * from './agent.js';
+export * from './agent.types.js';
+export * from './errors.js';
+export * from './hooks.js';

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@prysm-ai/core",
+  "version": "0.1.0",
+  "description": "Agent core engine",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0"
+  }
+}