@lupaflow/types 0.1.0

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name":  "@lupaflow/types",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/agent.ts

@@ -0,0 +1,46 @@
+import type { ProviderName } from "./provider"
+import type { Tool } from "./tool"
+
+export interface Personality {
+  name?: string
+  traits?: string[]
+  tone?: string
+  style?: string
+}
+
+export interface Goal {
+  description: string
+  priority?: number
+  completed?: boolean
+}
+
+export interface Constraint {
+  description: string
+  type?: "hard" | "soft"
+}
+
+export interface AgentConfig {
+  id?: string
+  name: string
+  provider: ProviderName
+  model?: string
+  systemPrompt?: string
+  personality?: Personality
+  goals?: Goal[]
+  constraints?: Constraint[]
+  temperature?: number
+  maxTokens?: number
+  topP?: number
+  maxRetries?: number
+  retryDelay?: number
+  maxContextMessages?: number
+  tools?: Tool[]
+  memory?: {
+    shortTerm?: boolean
+    longTerm?: boolean
+    semantic?: boolean
+    session?: boolean
+    user?: boolean
+    project?: boolean
+  }
+}

package/src/events.ts

@@ -0,0 +1,155 @@
+export type EventName =
+  | "agent:start"
+  | "agent:thinking"
+  | "agent:response"
+  | "agent:error"
+  | "agent:complete"
+  | "tool:start"
+  | "tool:finish"
+  | "tool:error"
+  | "memory:update"
+  | "memory:retrieve"
+  | "workflow:start"
+  | "workflow:step"
+  | "workflow:complete"
+  | "workflow:error"
+  | "provider:start"
+  | "provider:complete"
+  | "provider:error"
+  | "llm:token"
+
+export interface BaseEvent {
+  id: string
+  name: EventName
+  timestamp: number
+  agentId?: string
+  runId?: string
+}
+
+export interface AgentStartEvent extends BaseEvent {
+  name: "agent:start"
+  config: Record<string, unknown>
+}
+
+export interface AgentThinkingEvent extends BaseEvent {
+  name: "agent:thinking"
+  message: string
+}
+
+export interface AgentResponseEvent extends BaseEvent {
+  name: "agent:response"
+  content: string
+  tokens?: number
+  latencyMs?: number
+}
+
+export interface AgentErrorEvent extends BaseEvent {
+  name: "agent:error"
+  error: string
+  retryAttempt?: number
+}
+
+export interface AgentCompleteEvent extends BaseEvent {
+  name: "agent:complete"
+  totalTokens: number
+  totalLatencyMs: number
+  toolCalls: number
+}
+
+export interface ToolStartEvent extends BaseEvent {
+  name: "tool:start"
+  tool: string
+  args: Record<string, unknown>
+}
+
+export interface ToolFinishEvent extends BaseEvent {
+  name: "tool:finish"
+  tool: string
+  result: unknown
+  durationMs: number
+}
+
+export interface ToolErrorEvent extends BaseEvent {
+  name: "tool:error"
+  tool: string
+  error: string
+}
+
+export interface MemoryUpdateEvent extends BaseEvent {
+  name: "memory:update"
+  type: string
+  key: string
+}
+
+export interface MemoryRetrieveEvent extends BaseEvent {
+  name: "memory:retrieve"
+  type: string
+  key: string
+  results: number
+}
+
+export interface WorkflowStartEvent extends BaseEvent {
+  name: "workflow:start"
+  steps: number
+}
+
+export interface WorkflowStepEvent extends BaseEvent {
+  name: "workflow:step"
+  step: number
+  stepName: string
+  status: "running" | "completed" | "failed"
+}
+
+export interface WorkflowCompleteEvent extends BaseEvent {
+  name: "workflow:complete"
+  totalSteps: number
+  failedSteps: number
+  durationMs: number
+}
+
+export interface ProviderStartEvent extends BaseEvent {
+  name: "provider:start"
+  provider: string
+  model: string
+}
+
+export interface ProviderCompleteEvent extends BaseEvent {
+  name: "provider:complete"
+  provider: string
+  model: string
+  tokens: number
+  latencyMs: number
+  cost?: number
+}
+
+export interface ProviderErrorEvent extends BaseEvent {
+  name: "provider:error"
+  provider: string
+  model: string
+  error: string
+}
+
+export interface LLMTokenEvent extends BaseEvent {
+  name: "llm:token"
+  tokens: number
+  cost?: number
+}
+
+export type LupaEvent =
+  | AgentStartEvent
+  | AgentThinkingEvent
+  | AgentResponseEvent
+  | AgentErrorEvent
+  | AgentCompleteEvent
+  | ToolStartEvent
+  | ToolFinishEvent
+  | ToolErrorEvent
+  | MemoryUpdateEvent
+  | MemoryRetrieveEvent
+  | WorkflowStartEvent
+  | WorkflowStepEvent
+  | WorkflowCompleteEvent
+  | ProviderStartEvent
+  | ProviderCompleteEvent
+  | ProviderErrorEvent
+  | LLMTokenEvent

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./events"
+export * from "./provider"
+export * from "./tool"
+export * from "./memory"
+export * from "./agent"
+export * from "./workflow"
+export * from "./plugin"

package/src/memory.ts

@@ -0,0 +1,25 @@
+export type MemoryType = "short-term" | "long-term" | "semantic" | "session" | "user" | "project" | "vector"
+
+export interface MemoryEntry {
+  id: string
+  type: MemoryType
+  key: string
+  content: string
+  metadata?: Record<string, unknown>
+  timestamp: number
+  scope?: string
+}
+
+export interface MemoryQuery {
+  type?: MemoryType
+  key?: string
+  scope?: string
+  query?: string
+  limit?: number
+  threshold?: number
+}
+
+export interface MemorySearchResult {
+  entry: MemoryEntry
+  score: number
+}

package/src/plugin.ts

@@ -0,0 +1,18 @@
+import type { LupaEvent } from "./events"
+
+export interface Plugin {
+  name: string
+  version: string
+  description?: string
+  onLoad?: () => void | Promise<void>
+  onUnload?: () => void | Promise<void>
+  onEvent?: (event: LupaEvent) => void | Promise<void>
+  hooks?: {
+    beforeAgentRun?: (config: Record<string, unknown>) => Record<string, unknown>
+    afterAgentRun?: (result: unknown) => unknown
+    beforeToolCall?: (tool: string, args: Record<string, unknown>) => Record<string, unknown>
+    afterToolCall?: (result: unknown) => unknown
+    beforeProviderCall?: (provider: string, request: Record<string, unknown>) => Record<string, unknown>
+    afterProviderCall?: (response: Record<string, unknown>) => Record<string, unknown>
+  }
+}

package/src/provider.ts

@@ -0,0 +1,73 @@
+import type { Tool } from "./tool"
+
+export type ProviderName = "openai" | "anthropic" | "google" | "openrouter" | "groq" | "mistral" | "xai" | "ollama"
+
+export type ModelRole = "system" | "user" | "assistant" | "tool"
+
+export interface Message {
+  role: ModelRole
+  content: string | null
+  toolCallId?: string
+  name?: string
+  toolCalls?: Array<{
+    id: string
+    type: "function"
+    function: { name: string; arguments: string }
+  }>
+}
+
+export interface ToolCall {
+  id: string
+  name: string
+  args: Record<string, unknown>
+}
+
+export interface ToolResult {
+  toolCallId: string
+  name: string
+  content: string
+}
+
+export interface ProviderConfig {
+  apiKey?: string
+  baseUrl?: string
+  model?: string
+  temperature?: number
+  maxTokens?: number
+  topP?: number
+}
+
+export interface CompletionRequest {
+  messages: Message[]
+  tools?: Tool[]
+  systemPrompt?: string
+  temperature?: number
+  maxTokens?: number
+  topP?: number
+  model?: string
+}
+
+export interface CompletionResponse {
+  content: string | null
+  toolCalls: ToolCall[]
+  usage: {
+    promptTokens: number
+    completionTokens: number
+    totalTokens: number
+  }
+  model: string
+  latencyMs: number
+  finishReason: string
+}
+
+export type StreamChunk =
+  | { type: "text"; text: string }
+  | { type: "tool_call"; toolCall: ToolCall }
+  | {
+      type: "finish"
+      content: string
+      toolCalls: ToolCall[]
+      usage: { promptTokens: number; completionTokens: number; totalTokens: number }
+      model: string
+      finishReason: string
+    }

package/src/tool.ts

@@ -0,0 +1,20 @@
+export interface ToolParameter {
+  type: "string" | "number" | "boolean" | "array" | "object"
+  description: string
+  required?: boolean
+  enum?: string[]
+  items?: ToolParameter
+  properties?: Record<string, ToolParameter>
+}
+
+export interface ToolDefinition {
+  name: string
+  description: string
+  parameters: Record<string, ToolParameter>
+  required?: string[]
+}
+
+export interface Tool {
+  definition: ToolDefinition
+  execute: (args: Record<string, unknown>) => Promise<unknown>
+}

package/src/workflow.ts

@@ -0,0 +1,48 @@
+import type { AgentConfig } from "./agent"
+import type { Tool } from "./tool"
+
+export type WorkflowStepType = "agent" | "tool" | "transform" | "condition" | "loop"
+
+export interface WorkflowStepConfig {
+  id: string
+  name: string
+  type: WorkflowStepType
+  agent?: AgentConfig
+  tool?: Tool
+  input?: Record<string, unknown>
+  transform?: (input: unknown) => unknown
+  condition?: (input: unknown) => boolean
+  maxIterations?: number
+  onComplete?: (result: unknown) => void
+  onError?: (error: Error) => void
+}
+
+export interface WorkflowConfig {
+  id?: string
+  name: string
+  description?: string
+  steps: WorkflowStepConfig[]
+  maxRetries?: number
+  onComplete?: (results: unknown[]) => void
+  onError?: (error: Error) => void
+}
+
+export interface WorkflowResult {
+  id: string
+  name: string
+  success: boolean
+  steps: WorkflowStepResult[]
+  durationMs: number
+  error?: string
+}
+
+export interface WorkflowStepResult {
+  id: string
+  name: string
+  type: WorkflowStepType
+  status: "success" | "failed" | "skipped"
+  input?: unknown
+  output?: unknown
+  durationMs: number
+  error?: string
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})