@looopy-ai/core 1.0.1

package/dist/types/llm.d.ts

@@ -0,0 +1,24 @@
+import type { Observable } from 'rxjs';
+import type { AnyEvent, LLMEvent } from './event';
+import type { Message } from './message';
+import type { ToolCall, ToolDefinition } from './tools';
+export interface LLMProvider {
+    call(request: {
+        messages: Message[];
+        tools?: ToolDefinition[];
+        stream?: boolean;
+        sessionId?: string;
+    }): Observable<LLMEvent<AnyEvent>>;
+}
+export interface LLMResponse {
+    message: Message;
+    toolCalls?: ToolCall[];
+    finished: boolean;
+    finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+    model?: string;
+    usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+    };
+}

package/dist/types/llm.js

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

package/dist/types/message.d.ts

@@ -0,0 +1,9 @@
+import type { ToolCall } from './tools';
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+    contentDelta?: string;
+}

package/dist/types/message.js

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

package/dist/types/state.d.ts

@@ -0,0 +1,86 @@
+import type { LLMResponse } from './llm';
+import type { Message } from './message';
+import type { ToolCall, ToolDefinition, ToolResult } from './tools';
+export interface PersistedLoopState {
+    taskId: string;
+    agentId: string;
+    parentTaskId?: string;
+    contextId: string;
+    messages: Message[];
+    systemPrompt: string;
+    iteration: number;
+    completed: boolean;
+    availableTools: ToolDefinition[];
+    pendingToolCalls: ToolCall[];
+    completedToolCalls: Record<string, ToolResult>;
+    artifactIds: string[];
+    lastLLMResponse?: LLMResponse;
+    lastActivity: string;
+    resumeFrom: 'llm-call' | 'tool-execution' | 'sub-agent' | 'completed';
+    checkpointMetadata?: Record<string, unknown>;
+}
+export interface TaskStateStore {
+    save(taskId: string, state: PersistedLoopState): Promise<void>;
+    load(taskId: string): Promise<PersistedLoopState | null>;
+    exists(taskId: string): Promise<boolean>;
+    delete(taskId: string): Promise<void>;
+    listTasks(filter?: {
+        agentId?: string;
+        contextId?: string;
+        completedAfter?: Date;
+    }): Promise<string[]>;
+    setTTL(taskId: string, ttlSeconds: number): Promise<void>;
+}
+export interface ContextState {
+    contextId: string;
+    agentId: string;
+    title?: string;
+    description?: string;
+    tags?: string[];
+    status: 'active' | 'paused' | 'locked' | 'completed' | 'abandoned';
+    createdAt: string;
+    updatedAt: string;
+    lastActivityAt: string;
+    turnCount: number;
+    currentTurnId?: string;
+    pendingToolCalls?: ToolCall[];
+    pendingSubAgents?: string[];
+    lockedBy?: string;
+    lockedAt?: string;
+    lockExpiresAt?: string;
+    ownerId?: string;
+    sharedWith?: string[];
+    permissions?: Record<string, string[]>;
+    systemPrompt?: string;
+    preferredModel?: string;
+    messageCount?: number;
+    artifactCount?: number;
+    totalTokensUsed?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ContextStore {
+    save(state: ContextState): Promise<void>;
+    load(contextId: string): Promise<ContextState | null>;
+    exists(contextId: string): Promise<boolean>;
+    delete(contextId: string): Promise<void>;
+    list(filter?: {
+        agentId?: string;
+        ownerId?: string;
+        status?: ContextState['status'];
+        tags?: string[];
+        createdAfter?: Date;
+        createdBefore?: Date;
+        updatedAfter?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<ContextState[]>;
+    search(query: string, filter?: {
+        agentId?: string;
+        ownerId?: string;
+    }): Promise<ContextState[]>;
+    acquireLock(contextId: string, lockOwnerId: string, ttlSeconds?: number): Promise<boolean>;
+    releaseLock(contextId: string, lockOwnerId: string): Promise<void>;
+    refreshLock(contextId: string, lockOwnerId: string, ttlSeconds?: number): Promise<boolean>;
+    isLocked(contextId: string): Promise<boolean>;
+    update(contextId: string, updates: Partial<Omit<ContextState, 'contextId' | 'agentId' | 'createdAt'>>): Promise<void>;
+}

package/dist/types/state.js

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

package/dist/types/tools.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import type { ExecutionContext } from './context';
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+}
+export interface ToolResult {
+    toolCallId: string;
+    toolName: string;
+    success: boolean;
+    result: unknown;
+    error?: string;
+}
+export declare const JsonSchemaPropertySchema: z.ZodType<unknown>;
+export type JsonSchemaProperty = z.infer<typeof JsonSchemaPropertySchema>;
+export declare const FunctionParametersSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    additionalProperties: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FunctionParameters = z.infer<typeof FunctionParametersSchema>;
+export declare const ToolDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodObject<{
+        type: z.ZodLiteral<"object">;
+        properties: z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        additionalProperties: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ToolDefinition = z.infer<typeof ToolDefinitionSchema>;
+export declare function validateToolDefinitions(tools: unknown): ToolDefinition[];
+export declare function safeValidateToolDefinitions(tools: unknown): {
+    success: boolean;
+    data?: ToolDefinition[];
+    errors?: z.ZodIssue[];
+};
+export declare const ToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"function">;
+    function: z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ToolProvider = {
+    getTools(): Promise<ToolDefinition[]>;
+    execute(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult>;
+    canHandle(toolName: string): boolean;
+    executeBatch?(toolCalls: ToolCall[], context: ExecutionContext): Promise<ToolResult[]>;
+};

package/dist/types/tools.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export const JsonSchemaPropertySchema = z.lazy(() => z.object({
+    type: z.enum(['string', 'number', 'integer', 'boolean', 'array', 'object', 'null']),
+    description: z.string().optional(),
+    enum: z.array(z.union([z.string(), z.number()])).optional(),
+    default: z.unknown().optional(),
+    items: JsonSchemaPropertySchema.optional(),
+    minItems: z.number().optional(),
+    maxItems: z.number().optional(),
+    properties: z.record(z.string(), JsonSchemaPropertySchema).optional(),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.union([z.boolean(), JsonSchemaPropertySchema]).optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional(),
+    format: z.string().optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    multipleOf: z.number().optional(),
+}));
+export const FunctionParametersSchema = z.object({
+    type: z.literal('object'),
+    properties: z.record(z.string(), JsonSchemaPropertySchema),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.boolean().optional(),
+});
+export const ToolDefinitionSchema = z.object({
+    name: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[a-zA-Z0-9_-]+$/, 'Tool name must contain only alphanumeric characters, underscores, and hyphens'),
+    description: z.string().min(1).max(1024),
+    parameters: FunctionParametersSchema,
+});
+export function validateToolDefinitions(tools) {
+    return z.array(ToolDefinitionSchema).parse(tools);
+}
+export function safeValidateToolDefinitions(tools) {
+    const result = z.array(ToolDefinitionSchema).safeParse(tools);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, errors: result.error.issues };
+}
+export const ToolCallSchema = z.object({
+    id: z.string(),
+    type: z.literal('function'),
+    function: z.object({
+        name: z.string(),
+        arguments: z.record(z.string(), z.unknown()),
+    }),
+});

package/dist/utils/error.d.ts

@@ -0,0 +1,8 @@
+export type SerializedError = {
+    name: string;
+    message: string;
+    stack?: string;
+    cause?: SerializedError;
+    [key: string]: unknown;
+};
+export declare const serializeError: (error: unknown) => SerializedError;

package/dist/utils/error.js

@@ -0,0 +1,23 @@
+export const serializeError = (error) => {
+    if (error instanceof Error) {
+        return {
+            ...error,
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+            cause: error.cause ? serializeError(error.cause) : undefined,
+        };
+    }
+    if (typeof error === 'object' && error !== null) {
+        return {
+            name: 'NonErrorObject',
+            message: 'An error occurred, but it is not an instance of Error.',
+            ...error,
+            cause: 'cause' in error && error.cause ? serializeError(error.cause) : undefined,
+        };
+    }
+    return {
+        name: 'NonObjectError',
+        message: JSON.stringify(error),
+    };
+};

package/dist/utils/process-signals.d.ts

@@ -0,0 +1,3 @@
+export type SignalListener = () => void | Promise<void>;
+export declare function registerSignalListener(signal: NodeJS.Signals, listener: SignalListener): void;
+export declare function unregisterSignalListener(signal: NodeJS.Signals, listener: SignalListener): void;

package/dist/utils/process-signals.js

@@ -0,0 +1,67 @@
+import { getLogger } from '../core/logger';
+import { serializeError } from './error';
+const listeners = new Map();
+const processHandlers = new Map();
+const signalLogger = getLogger({ component: 'process-signal-coordinator' });
+function isProcessAvailable() {
+    return typeof process !== 'undefined' && typeof process.on === 'function';
+}
+export function registerSignalListener(signal, listener) {
+    if (!isProcessAvailable()) {
+        return;
+    }
+    const signalListeners = listeners.get(signal) ?? new Set();
+    signalListeners.add(listener);
+    listeners.set(signal, signalListeners);
+    ensureProcessHandler(signal);
+}
+export function unregisterSignalListener(signal, listener) {
+    if (!isProcessAvailable()) {
+        return;
+    }
+    const signalListeners = listeners.get(signal);
+    if (!signalListeners) {
+        return;
+    }
+    signalListeners.delete(listener);
+    if (signalListeners.size === 0) {
+        listeners.delete(signal);
+        removeProcessHandler(signal);
+    }
+}
+function ensureProcessHandler(signal) {
+    if (processHandlers.has(signal)) {
+        return;
+    }
+    const handler = () => {
+        const signalListeners = listeners.get(signal);
+        if (!signalListeners || signalListeners.size === 0) {
+            return;
+        }
+        signalLogger.info({ signal, listenerCount: signalListeners.size }, 'Received process signal; notifying registered listeners');
+        const listenersSnapshot = Array.from(signalListeners);
+        void Promise.allSettled(listenersSnapshot.map(async (listener) => {
+            try {
+                await listener();
+            }
+            catch (error) {
+                signalLogger.error({ signal, error: serializeError(error) }, 'Signal listener failed');
+            }
+        }));
+    };
+    process.on(signal, handler);
+    processHandlers.set(signal, handler);
+}
+function removeProcessHandler(signal) {
+    const handler = processHandlers.get(signal);
+    if (!handler) {
+        return;
+    }
+    if (typeof process.off === 'function') {
+        process.off(signal, handler);
+    }
+    else if (typeof process.removeListener === 'function') {
+        process.removeListener(signal, handler);
+    }
+    processHandlers.delete(signal);
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@looopy-ai/core",
+  "version": "1.0.1",
+  "description": "RxJS-based AI agent framework",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./ts": "./src/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "agent",
+    "ai",
+    "rxjs",
+    "a2a",
+    "llm"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.207.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.207.0",
+    "@opentelemetry/instrumentation": "^0.207.0",
+    "@opentelemetry/resources": "^2.2.0",
+    "@opentelemetry/sdk-metrics": "^2.2.0",
+    "@opentelemetry/sdk-trace-base": "^2.2.0",
+    "@opentelemetry/sdk-trace-node": "^2.2.0",
+    "@opentelemetry/semantic-conventions": "^1.37.0",
+    "pino-pretty": "^13.1.2"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check:exports": "pnpx ts-unused-exports ./tsconfig.json --excludePathsFromReport='index'",
+    "check:types": "tsc --noEmit",
+    "test": "CI=true vitest",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
+    "build": "tsc -p tsconfig.esm.json",
+    "lint": "biome check src tests",
+    "lint:fix": "biome check --write src tests"
+  }
+}