ruvbot 0.1.0

package/dist/core/entities/types.d.ts

@@ -0,0 +1,677 @@
+/**
+ * Core type definitions for RuvBot entities
+ */
+import { z } from 'zod';
+export declare const TenantSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    slug: string;
+    settings: Record<string, unknown>;
+}, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    slug: string;
+    settings?: Record<string, unknown> | undefined;
+}>;
+export type Tenant = z.infer<typeof TenantSchema>;
+export declare const AgentStatusSchema: z.ZodEnum<["idle", "processing", "learning", "error", "offline"]>;
+export type AgentStatus = z.infer<typeof AgentStatusSchema>;
+export declare const AgentConfigSchema: z.ZodObject<{
+    modelProvider: z.ZodDefault<z.ZodEnum<["anthropic", "openai", "local"]>>;
+    modelId: z.ZodDefault<z.ZodString>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    learningEnabled: z.ZodDefault<z.ZodBoolean>;
+    memoryEnabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    temperature: number;
+    maxTokens: number;
+    skills: string[];
+    modelProvider: "anthropic" | "openai" | "local";
+    modelId: string;
+    learningEnabled: boolean;
+    memoryEnabled: boolean;
+    systemPrompt?: string | undefined;
+}, {
+    temperature?: number | undefined;
+    maxTokens?: number | undefined;
+    skills?: string[] | undefined;
+    systemPrompt?: string | undefined;
+    modelProvider?: "anthropic" | "openai" | "local" | undefined;
+    modelId?: string | undefined;
+    learningEnabled?: boolean | undefined;
+    memoryEnabled?: boolean | undefined;
+}>;
+export type AgentConfig = z.infer<typeof AgentConfigSchema>;
+export declare const AgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<["idle", "processing", "learning", "error", "offline"]>>;
+    config: z.ZodObject<{
+        modelProvider: z.ZodDefault<z.ZodEnum<["anthropic", "openai", "local"]>>;
+        modelId: z.ZodDefault<z.ZodString>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        skills: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        learningEnabled: z.ZodDefault<z.ZodBoolean>;
+        memoryEnabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        temperature: number;
+        maxTokens: number;
+        skills: string[];
+        modelProvider: "anthropic" | "openai" | "local";
+        modelId: string;
+        learningEnabled: boolean;
+        memoryEnabled: boolean;
+        systemPrompt?: string | undefined;
+    }, {
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        skills?: string[] | undefined;
+        systemPrompt?: string | undefined;
+        modelProvider?: "anthropic" | "openai" | "local" | undefined;
+        modelId?: string | undefined;
+        learningEnabled?: boolean | undefined;
+        memoryEnabled?: boolean | undefined;
+    }>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    status: "idle" | "processing" | "learning" | "error" | "offline";
+    name: string;
+    id: string;
+    metadata: Record<string, unknown>;
+    tenantId: string;
+    config: {
+        temperature: number;
+        maxTokens: number;
+        skills: string[];
+        modelProvider: "anthropic" | "openai" | "local";
+        modelId: string;
+        learningEnabled: boolean;
+        memoryEnabled: boolean;
+        systemPrompt?: string | undefined;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    description?: string | undefined;
+}, {
+    name: string;
+    id: string;
+    tenantId: string;
+    config: {
+        temperature?: number | undefined;
+        maxTokens?: number | undefined;
+        skills?: string[] | undefined;
+        systemPrompt?: string | undefined;
+        modelProvider?: "anthropic" | "openai" | "local" | undefined;
+        modelId?: string | undefined;
+        learningEnabled?: boolean | undefined;
+        memoryEnabled?: boolean | undefined;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    status?: "idle" | "processing" | "learning" | "error" | "offline" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+}>;
+export type Agent = z.infer<typeof AgentSchema>;
+export declare const MessageRoleSchema: z.ZodEnum<["user", "assistant", "system", "tool"]>;
+export type MessageRole = z.infer<typeof MessageRoleSchema>;
+export declare const MessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<["user", "assistant", "system", "tool"]>;
+    content: z.ZodString;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        arguments: Record<string, unknown>;
+    }, {
+        name: string;
+        id: string;
+        arguments: Record<string, unknown>;
+    }>, "many">>;
+    toolResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        toolCallId: z.ZodString;
+        result: z.ZodUnknown;
+        isError: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        toolCallId: string;
+        isError: boolean;
+        result?: unknown;
+    }, {
+        toolCallId: string;
+        result?: unknown;
+        isError?: boolean | undefined;
+    }>, "many">>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    createdAt: Date;
+    role: "user" | "assistant" | "system" | "tool";
+    toolCalls?: {
+        name: string;
+        id: string;
+        arguments: Record<string, unknown>;
+    }[] | undefined;
+    toolResults?: {
+        toolCallId: string;
+        isError: boolean;
+        result?: unknown;
+    }[] | undefined;
+}, {
+    id: string;
+    content: string;
+    createdAt: Date;
+    role: "user" | "assistant" | "system" | "tool";
+    toolCalls?: {
+        name: string;
+        id: string;
+        arguments: Record<string, unknown>;
+    }[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    toolResults?: {
+        toolCallId: string;
+        result?: unknown;
+        isError?: boolean | undefined;
+    }[] | undefined;
+}>;
+export type Message = z.infer<typeof MessageSchema>;
+export declare const SessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    agentId: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
+    channelId: z.ZodOptional<z.ZodString>;
+    channelType: z.ZodOptional<z.ZodEnum<["slack", "discord", "webhook", "api", "cli"]>>;
+    messages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<["user", "assistant", "system", "tool"]>;
+        content: z.ZodString;
+        toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            id: string;
+            arguments: Record<string, unknown>;
+        }, {
+            name: string;
+            id: string;
+            arguments: Record<string, unknown>;
+        }>, "many">>;
+        toolResults: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            toolCallId: z.ZodString;
+            result: z.ZodUnknown;
+            isError: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            toolCallId: string;
+            isError: boolean;
+            result?: unknown;
+        }, {
+            toolCallId: string;
+            result?: unknown;
+            isError?: boolean | undefined;
+        }>, "many">>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        content: string;
+        metadata: Record<string, unknown>;
+        createdAt: Date;
+        role: "user" | "assistant" | "system" | "tool";
+        toolCalls?: {
+            name: string;
+            id: string;
+            arguments: Record<string, unknown>;
+        }[] | undefined;
+        toolResults?: {
+            toolCallId: string;
+            isError: boolean;
+            result?: unknown;
+        }[] | undefined;
+    }, {
+        id: string;
+        content: string;
+        createdAt: Date;
+        role: "user" | "assistant" | "system" | "tool";
+        toolCalls?: {
+            name: string;
+            id: string;
+            arguments: Record<string, unknown>;
+        }[] | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        toolResults?: {
+            toolCallId: string;
+            result?: unknown;
+            isError?: boolean | undefined;
+        }[] | undefined;
+    }>, "many">>;
+    context: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    expiresAt: z.ZodOptional<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    messages: {
+        id: string;
+        content: string;
+        metadata: Record<string, unknown>;
+        createdAt: Date;
+        role: "user" | "assistant" | "system" | "tool";
+        toolCalls?: {
+            name: string;
+            id: string;
+            arguments: Record<string, unknown>;
+        }[] | undefined;
+        toolResults?: {
+            toolCallId: string;
+            isError: boolean;
+            result?: unknown;
+        }[] | undefined;
+    }[];
+    agentId: string;
+    tenantId: string;
+    createdAt: Date;
+    context: Record<string, unknown>;
+    updatedAt: Date;
+    isActive: boolean;
+    channelId?: string | undefined;
+    channelType?: "slack" | "discord" | "api" | "cli" | "webhook" | undefined;
+    userId?: string | undefined;
+    expiresAt?: Date | undefined;
+}, {
+    id: string;
+    agentId: string;
+    tenantId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    messages?: {
+        id: string;
+        content: string;
+        createdAt: Date;
+        role: "user" | "assistant" | "system" | "tool";
+        toolCalls?: {
+            name: string;
+            id: string;
+            arguments: Record<string, unknown>;
+        }[] | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        toolResults?: {
+            toolCallId: string;
+            result?: unknown;
+            isError?: boolean | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    channelId?: string | undefined;
+    channelType?: "slack" | "discord" | "api" | "cli" | "webhook" | undefined;
+    userId?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+    expiresAt?: Date | undefined;
+    isActive?: boolean | undefined;
+}>;
+export type Session = z.infer<typeof SessionSchema>;
+export declare const MemoryTypeSchema: z.ZodEnum<["episodic", "semantic", "procedural", "working"]>;
+export type MemoryType = z.infer<typeof MemoryTypeSchema>;
+export declare const MemoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    agentId: z.ZodString;
+    type: z.ZodEnum<["episodic", "semantic", "procedural", "working"]>;
+    content: z.ZodString;
+    embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    importance: z.ZodDefault<z.ZodNumber>;
+    accessCount: z.ZodDefault<z.ZodNumber>;
+    lastAccessedAt: z.ZodOptional<z.ZodDate>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    expiresAt: z.ZodOptional<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    type: "episodic" | "semantic" | "procedural" | "working";
+    id: string;
+    content: string;
+    agentId: string;
+    metadata: Record<string, unknown>;
+    tenantId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    importance: number;
+    accessCount: number;
+    tags: string[];
+    expiresAt?: Date | undefined;
+    embedding?: number[] | undefined;
+    lastAccessedAt?: Date | undefined;
+}, {
+    type: "episodic" | "semantic" | "procedural" | "working";
+    id: string;
+    content: string;
+    agentId: string;
+    tenantId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata?: Record<string, unknown> | undefined;
+    expiresAt?: Date | undefined;
+    embedding?: number[] | undefined;
+    importance?: number | undefined;
+    accessCount?: number | undefined;
+    lastAccessedAt?: Date | undefined;
+    tags?: string[] | undefined;
+}>;
+export type MemoryEntry = z.infer<typeof MemoryEntrySchema>;
+export declare const SkillParameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    name: string;
+    description: string;
+    required: boolean;
+    default?: unknown;
+}, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    name: string;
+    description: string;
+    default?: unknown;
+    required?: boolean | undefined;
+}>;
+export type SkillParameter = z.infer<typeof SkillParameterSchema>;
+export declare const SkillSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    category: z.ZodDefault<z.ZodString>;
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        required: boolean;
+        default?: unknown;
+    }, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        default?: unknown;
+        required?: boolean | undefined;
+    }>, "many">>;
+    examples: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        input: z.ZodString;
+        output: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        input: string;
+        output: string;
+    }, {
+        input: string;
+        output: string;
+    }>, "many">>;
+    isBuiltin: z.ZodDefault<z.ZodBoolean>;
+    isEnabled: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    id: string;
+    metadata: Record<string, unknown>;
+    description: string;
+    category: string;
+    parameters: {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        required: boolean;
+        default?: unknown;
+    }[];
+    examples: {
+        input: string;
+        output: string;
+    }[];
+    isBuiltin: boolean;
+    isEnabled: boolean;
+}, {
+    name: string;
+    version: string;
+    id: string;
+    description: string;
+    metadata?: Record<string, unknown> | undefined;
+    category?: string | undefined;
+    parameters?: {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        default?: unknown;
+        required?: boolean | undefined;
+    }[] | undefined;
+    examples?: {
+        input: string;
+        output: string;
+    }[] | undefined;
+    isBuiltin?: boolean | undefined;
+    isEnabled?: boolean | undefined;
+}>;
+export type Skill = z.infer<typeof SkillSchema>;
+export interface SkillExecutor {
+    execute(params: Record<string, unknown>, context: SkillContext): Promise<SkillResult>;
+}
+export interface SkillContext {
+    tenantId: string;
+    agentId: string;
+    sessionId: string;
+    userId?: string;
+    memory: MemoryEntry[];
+}
+export interface SkillResult {
+    success: boolean;
+    output: unknown;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare const DomainEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    tenantId: z.ZodString;
+    aggregateId: z.ZodString;
+    aggregateType: z.ZodEnum<["agent", "session", "memory", "skill", "task"]>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    id: string;
+    metadata: Record<string, unknown>;
+    tenantId: string;
+    timestamp: Date;
+    aggregateId: string;
+    aggregateType: "skill" | "memory" | "session" | "agent" | "task";
+    payload: Record<string, unknown>;
+}, {
+    type: string;
+    id: string;
+    tenantId: string;
+    timestamp: Date;
+    aggregateId: string;
+    aggregateType: "skill" | "memory" | "session" | "agent" | "task";
+    payload: Record<string, unknown>;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type DomainEvent = z.infer<typeof DomainEventSchema>;
+export declare const TaskStatusSchema: z.ZodEnum<["pending", "queued", "running", "completed", "failed", "cancelled"]>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    type: z.ZodString;
+    priority: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "queued", "running", "completed", "failed", "cancelled"]>>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    attempts: z.ZodDefault<z.ZodNumber>;
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    scheduledAt: z.ZodOptional<z.ZodDate>;
+    startedAt: z.ZodOptional<z.ZodDate>;
+    completedAt: z.ZodOptional<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    status: "running" | "pending" | "completed" | "failed" | "queued" | "cancelled";
+    id: string;
+    tenantId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    payload: Record<string, unknown>;
+    priority: number;
+    attempts: number;
+    maxAttempts: number;
+    error?: string | undefined;
+    result?: unknown;
+    scheduledAt?: Date | undefined;
+    startedAt?: Date | undefined;
+    completedAt?: Date | undefined;
+}, {
+    type: string;
+    id: string;
+    tenantId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    payload: Record<string, unknown>;
+    error?: string | undefined;
+    status?: "running" | "pending" | "completed" | "failed" | "queued" | "cancelled" | undefined;
+    result?: unknown;
+    priority?: number | undefined;
+    attempts?: number | undefined;
+    maxAttempts?: number | undefined;
+    scheduledAt?: Date | undefined;
+    startedAt?: Date | undefined;
+    completedAt?: Date | undefined;
+}>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const TrajectoryStepSchema: z.ZodObject<{
+    action: z.ZodString;
+    input: z.ZodUnknown;
+    output: z.ZodUnknown;
+    confidence: z.ZodNumber;
+    duration: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    action: string;
+    timestamp: Date;
+    confidence: number;
+    duration: number;
+    input?: unknown;
+    output?: unknown;
+}, {
+    action: string;
+    timestamp: Date;
+    confidence: number;
+    duration: number;
+    input?: unknown;
+    output?: unknown;
+}>;
+export type TrajectoryStep = z.infer<typeof TrajectoryStepSchema>;
+export declare const TrajectorySchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        input: z.ZodUnknown;
+        output: z.ZodUnknown;
+        confidence: z.ZodNumber;
+        duration: z.ZodNumber;
+        timestamp: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        action: string;
+        timestamp: Date;
+        confidence: number;
+        duration: number;
+        input?: unknown;
+        output?: unknown;
+    }, {
+        action: string;
+        timestamp: Date;
+        confidence: number;
+        duration: number;
+        input?: unknown;
+        output?: unknown;
+    }>, "many">;
+    outcome: z.ZodEnum<["success", "failure", "partial", "unknown"]>;
+    reward: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    agentId: string;
+    sessionId: string;
+    metadata: Record<string, unknown>;
+    tenantId: string;
+    createdAt: Date;
+    steps: {
+        action: string;
+        timestamp: Date;
+        confidence: number;
+        duration: number;
+        input?: unknown;
+        output?: unknown;
+    }[];
+    outcome: "unknown" | "success" | "failure" | "partial";
+    reward: number;
+}, {
+    id: string;
+    agentId: string;
+    sessionId: string;
+    tenantId: string;
+    createdAt: Date;
+    steps: {
+        action: string;
+        timestamp: Date;
+        confidence: number;
+        duration: number;
+        input?: unknown;
+        output?: unknown;
+    }[];
+    outcome: "unknown" | "success" | "failure" | "partial";
+    metadata?: Record<string, unknown> | undefined;
+    reward?: number | undefined;
+}>;
+export type Trajectory = z.infer<typeof TrajectorySchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/entities/types.d.ts.map

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