@radaros/core 0.3.4 → 0.3.6

package/src/vector/qdrant.ts

@@ -1,203 +0,0 @@
-import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
-import { BaseVectorStore } from "./base.js";
-import type {
-  VectorDocument,
-  VectorSearchResult,
-  VectorSearchOptions,
-  EmbeddingProvider,
-} from "./types.js";
-
-const _require = createRequire(import.meta.url);
-
-export interface QdrantConfig {
-  url?: string;
-  apiKey?: string;
-  dimensions?: number;
-  checkCompatibility?: boolean;
-}
-
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-
-/**
- * Deterministic UUID from an arbitrary string.
- * Qdrant only accepts UUIDs or unsigned ints as point IDs,
- * so we hash arbitrary strings into valid UUID v4 format
- * and store the original ID in the payload under `_originalId`.
- */
-function stringToUUID(str: string): string {
-  const hex = createHash("md5").update(str).digest("hex");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    "4" + hex.slice(13, 16),
-    "8" + hex.slice(17, 20),
-    hex.slice(20, 32),
-  ].join("-");
-}
-
-function toQdrantId(id: string): string | number {
-  if (/^\d+$/.test(id)) return Number(id);
-  if (UUID_RE.test(id)) return id;
-  return stringToUUID(id);
-}
-
-export class QdrantVectorStore extends BaseVectorStore {
-  private client: any;
-  private dimensions: number;
-  private initializedCollections = new Set<string>();
-
-  constructor(config: QdrantConfig = {}, embedder?: EmbeddingProvider) {
-    super(embedder);
-    this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
-    try {
-      const { QdrantClient } = _require("@qdrant/js-client-rest");
-      this.client = new QdrantClient({
-        url: config.url ?? "http://localhost:6333",
-        apiKey: config.apiKey,
-        checkCompatibility: config.checkCompatibility ?? false,
-      });
-    } catch {
-      throw new Error(
-        "@qdrant/js-client-rest is required for QdrantVectorStore. Install it: npm install @qdrant/js-client-rest"
-      );
-    }
-  }
-
-  async initialize(): Promise<void> {}
-
-  private async ensureCollection(collection: string): Promise<void> {
-    if (this.initializedCollections.has(collection)) return;
-    try {
-      await this.client.getCollection(collection);
-    } catch {
-      await this.client.createCollection(collection, {
-        vectors: {
-          size: this.dimensions,
-          distance: "Cosine",
-        },
-      });
-    }
-    this.initializedCollections.add(collection);
-  }
-
-  async upsert(collection: string, doc: VectorDocument): Promise<void> {
-    await this.ensureCollection(collection);
-    const embedding = await this.ensureEmbedding(doc);
-    await this.client.upsert(collection, {
-      wait: true,
-      points: [
-        {
-          id: toQdrantId(doc.id),
-          vector: embedding,
-          payload: {
-            _originalId: doc.id,
-            content: doc.content,
-            ...(doc.metadata ?? {}),
-          },
-        },
-      ],
-    });
-  }
-
-  async upsertBatch(collection: string, docs: VectorDocument[]): Promise<void> {
-    await this.ensureCollection(collection);
-    const points = await Promise.all(
-      docs.map(async (doc) => {
-        const embedding = await this.ensureEmbedding(doc);
-        return {
-          id: toQdrantId(doc.id),
-          vector: embedding,
-          payload: {
-            _originalId: doc.id,
-            content: doc.content,
-            ...(doc.metadata ?? {}),
-          },
-        };
-      })
-    );
-    await this.client.upsert(collection, { wait: true, points });
-  }
-
-  async search(
-    collection: string,
-    query: number[] | string,
-    options?: VectorSearchOptions
-  ): Promise<VectorSearchResult[]> {
-    await this.ensureCollection(collection);
-    const vec = await this.ensureQueryVector(query);
-    const topK = options?.topK ?? 10;
-
-    const searchParams: Record<string, unknown> = {
-      vector: vec,
-      limit: topK,
-      with_payload: true,
-    };
-
-    if (options?.filter) {
-      searchParams.filter = {
-        must: Object.entries(options.filter).map(([key, value]) => ({
-          key,
-          match: { value },
-        })),
-      };
-    }
-
-    if (options?.minScore != null) {
-      searchParams.score_threshold = options.minScore;
-    }
-
-    const results = await this.client.search(collection, searchParams);
-
-    return results.map((r: any) => {
-      const { _originalId, content, ...rest } = r.payload ?? {};
-      return {
-        id: _originalId ?? String(r.id),
-        content: content ?? "",
-        score: r.score,
-        metadata: rest,
-      };
-    });
-  }
-
-  async delete(collection: string, id: string): Promise<void> {
-    await this.ensureCollection(collection);
-    await this.client.delete(collection, {
-      wait: true,
-      points: [toQdrantId(id)],
-    });
-  }
-
-  async get(collection: string, id: string): Promise<VectorDocument | null> {
-    await this.ensureCollection(collection);
-    try {
-      const results = await this.client.retrieve(collection, {
-        ids: [toQdrantId(id)],
-        with_payload: true,
-      });
-      if (!results || results.length === 0) return null;
-      const point = results[0];
-      const { _originalId, content, ...rest } = point.payload ?? {};
-      return {
-        id: _originalId ?? String(point.id),
-        content: content ?? "",
-        metadata: rest,
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  async dropCollection(collection: string): Promise<void> {
-    try {
-      await this.client.deleteCollection(collection);
-    } catch {
-      // collection may not exist
-    }
-    this.initializedCollections.delete(collection);
-  }
-
-  async close(): Promise<void> {
-    // Qdrant JS client doesn't require explicit close
-  }
-}

package/src/vector/types.ts

@@ -1,55 +0,0 @@
-export interface VectorDocument {
-  id: string;
-  content: string;
-  embedding?: number[];
-  metadata?: Record<string, unknown>;
-}
-
-export interface VectorSearchResult {
-  id: string;
-  content: string;
-  score: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface VectorSearchOptions {
-  topK?: number;
-  filter?: Record<string, unknown>;
-  minScore?: number;
-}
-
-export interface EmbeddingProvider {
-  readonly dimensions: number;
-  embed(text: string): Promise<number[]>;
-  embedBatch(texts: string[]): Promise<number[][]>;
-}
-
-export interface VectorStore {
-  /** Initialize collections/indexes. Call once before use. */
-  initialize(): Promise<void>;
-
-  /** Upsert a single document (embedding computed if not provided). */
-  upsert(collection: string, doc: VectorDocument): Promise<void>;
-
-  /** Upsert multiple documents in batch. */
-  upsertBatch(collection: string, docs: VectorDocument[]): Promise<void>;
-
-  /** Similarity search by vector or text query. */
-  search(
-    collection: string,
-    query: number[] | string,
-    options?: VectorSearchOptions
-  ): Promise<VectorSearchResult[]>;
-
-  /** Delete a document by ID. */
-  delete(collection: string, id: string): Promise<void>;
-
-  /** Get a document by ID. */
-  get(collection: string, id: string): Promise<VectorDocument | null>;
-
-  /** Drop an entire collection. */
-  dropCollection(collection: string): Promise<void>;
-
-  /** Close connections. */
-  close(): Promise<void>;
-}

package/src/workflow/step-runner.ts

@@ -1,303 +0,0 @@
-import type { RunContext } from "../agent/run-context.js";
-import type {
-  StepDef,
-  StepResult,
-  AgentStep,
-  FunctionStep,
-  ConditionStep,
-  ParallelStep,
-} from "./types.js";
-
-function isAgentStep<T>(step: StepDef<T>): step is AgentStep<T> {
-  return "agent" in step;
-}
-
-function isFunctionStep<T>(step: StepDef<T>): step is FunctionStep<T> {
-  return "run" in step;
-}
-
-function isConditionStep<T>(step: StepDef<T>): step is ConditionStep<T> {
-  return "condition" in step;
-}
-
-function isParallelStep<T>(step: StepDef<T>): step is ParallelStep<T> {
-  return "parallel" in step;
-}
-
-export class StepRunner<TState extends Record<string, unknown>> {
-  private retryPolicy?: { maxRetries: number; backoffMs: number };
-
-  constructor(retryPolicy?: { maxRetries: number; backoffMs: number }) {
-    this.retryPolicy = retryPolicy;
-  }
-
-  async executeSteps(
-    steps: StepDef<TState>[],
-    state: TState,
-    ctx: RunContext
-  ): Promise<{ state: TState; results: StepResult[] }> {
-    let currentState = { ...state };
-    const allResults: StepResult[] = [];
-
-    for (const step of steps) {
-      const { state: newState, results } = await this.executeStep(
-        step,
-        currentState,
-        ctx
-      );
-      currentState = newState;
-      allResults.push(...results);
-    }
-
-    return { state: currentState, results: allResults };
-  }
-
-  private async executeStep(
-    step: StepDef<TState>,
-    state: TState,
-    ctx: RunContext
-  ): Promise<{ state: TState; results: StepResult[] }> {
-    if (isConditionStep(step)) {
-      return this.executeConditionStep(step, state, ctx);
-    }
-
-    if (isParallelStep(step)) {
-      return this.executeParallelStep(step, state, ctx);
-    }
-
-    if (isAgentStep(step)) {
-      return this.executeAgentStep(step, state, ctx);
-    }
-
-    if (isFunctionStep(step)) {
-      return this.executeFunctionStep(step, state, ctx);
-    }
-
-    return { state, results: [] };
-  }
-
-  private async executeAgentStep(
-    step: AgentStep<TState>,
-    state: TState,
-    ctx: RunContext
-  ): Promise<{ state: TState; results: StepResult[] }> {
-    const startTime = Date.now();
-
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start",
-    });
-
-    const execute = async (): Promise<StepResult> => {
-      const input = step.inputFrom
-        ? step.inputFrom(state)
-        : JSON.stringify(state);
-
-      const output = await step.agent.run(input, {
-        sessionId: ctx.sessionId,
-      });
-
-      const newState = {
-        ...state,
-        [`${step.name}_output`]: output.text,
-      } as TState;
-
-      Object.assign(state, newState);
-
-      return {
-        stepName: step.name,
-        status: "done",
-        durationMs: Date.now() - startTime,
-      };
-    };
-
-    const result = await this.withRetry(step.name, execute, ctx);
-    return { state, results: [result] };
-  }
-
-  private async executeFunctionStep(
-    step: FunctionStep<TState>,
-    state: TState,
-    ctx: RunContext
-  ): Promise<{ state: TState; results: StepResult[] }> {
-    const startTime = Date.now();
-
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start",
-    });
-
-    const execute = async (): Promise<StepResult> => {
-      const patch = await step.run(state, ctx);
-      Object.assign(state, patch);
-
-      return {
-        stepName: step.name,
-        status: "done",
-        durationMs: Date.now() - startTime,
-      };
-    };
-
-    const result = await this.withRetry(step.name, execute, ctx);
-    return { state, results: [result] };
-  }
-
-  private async executeConditionStep(
-    step: ConditionStep<TState>,
-    state: TState,
-    ctx: RunContext
-  ): Promise<{ state: TState; results: StepResult[] }> {
-    const startTime = Date.now();
-
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start",
-    });
-
-    if (step.condition(state)) {
-      const { state: newState, results } = await this.executeSteps(
-        step.steps,
-        state,
-        ctx
-      );
-
-      ctx.eventBus.emit("workflow.step", {
-        runId: ctx.runId,
-        stepName: step.name,
-        status: "done",
-      });
-
-      return {
-        state: newState,
-        results: [
-          {
-            stepName: step.name,
-            status: "done",
-            durationMs: Date.now() - startTime,
-          },
-          ...results,
-        ],
-      };
-    }
-
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "done",
-    });
-
-    return {
-      state,
-      results: [
-        {
-          stepName: step.name,
-          status: "skipped",
-          durationMs: Date.now() - startTime,
-        },
-      ],
-    };
-  }
-
-  private async executeParallelStep(
-    step: ParallelStep<TState>,
-    state: TState,
-    ctx: RunContext
-  ): Promise<{ state: TState; results: StepResult[] }> {
-    const startTime = Date.now();
-
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "start",
-    });
-
-    const settled = await Promise.allSettled(
-      step.parallel.map((s) => this.executeStep(s, { ...state }, ctx))
-    );
-
-    const allResults: StepResult[] = [];
-    let mergedState = { ...state };
-
-    for (const result of settled) {
-      if (result.status === "fulfilled") {
-        Object.assign(mergedState, result.value.state);
-        allResults.push(...result.value.results);
-      } else {
-        allResults.push({
-          stepName: step.name,
-          status: "error",
-          error: result.reason?.message ?? "Unknown error",
-          durationMs: Date.now() - startTime,
-        });
-      }
-    }
-
-    ctx.eventBus.emit("workflow.step", {
-      runId: ctx.runId,
-      stepName: step.name,
-      status: "done",
-    });
-
-    return {
-      state: mergedState,
-      results: [
-        {
-          stepName: step.name,
-          status: "done",
-          durationMs: Date.now() - startTime,
-        },
-        ...allResults,
-      ],
-    };
-  }
-
-  private async withRetry(
-    stepName: string,
-    fn: () => Promise<StepResult>,
-    ctx: RunContext
-  ): Promise<StepResult> {
-    const maxRetries = this.retryPolicy?.maxRetries ?? 0;
-    const backoffMs = this.retryPolicy?.backoffMs ?? 1000;
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const result = await fn();
-
-        ctx.eventBus.emit("workflow.step", {
-          runId: ctx.runId,
-          stepName,
-          status: "done",
-        });
-
-        return result;
-      } catch (error) {
-        if (attempt === maxRetries) {
-          const err =
-            error instanceof Error ? error : new Error(String(error));
-
-          ctx.eventBus.emit("workflow.step", {
-            runId: ctx.runId,
-            stepName,
-            status: "error",
-          });
-
-          return {
-            stepName,
-            status: "error",
-            error: err.message,
-            durationMs: 0,
-          };
-        }
-
-        await new Promise((resolve) =>
-          setTimeout(resolve, backoffMs * Math.pow(2, attempt))
-        );
-      }
-    }
-
-    return { stepName, status: "error", error: "Exhausted retries", durationMs: 0 };
-  }
-}

package/src/workflow/types.ts

@@ -1,55 +0,0 @@
-import type { Agent } from "../agent/agent.js";
-import type { RunContext } from "../agent/run-context.js";
-import type { StorageDriver } from "../storage/driver.js";
-import type { EventBus } from "../events/event-bus.js";
-
-export type StepDef<TState> =
-  | AgentStep<TState>
-  | FunctionStep<TState>
-  | ConditionStep<TState>
-  | ParallelStep<TState>;
-
-export interface AgentStep<TState> {
-  name: string;
-  agent: Agent;
-  inputFrom?: (state: TState) => string;
-}
-
-export interface FunctionStep<TState> {
-  name: string;
-  run: (state: TState, ctx: RunContext) => Promise<Partial<TState>>;
-}
-
-export interface ConditionStep<TState> {
-  name: string;
-  condition: (state: TState) => boolean;
-  steps: StepDef<TState>[];
-}
-
-export interface ParallelStep<TState> {
-  name: string;
-  parallel: StepDef<TState>[];
-}
-
-export interface WorkflowConfig<
-  TState extends Record<string, unknown> = Record<string, unknown>,
-> {
-  name: string;
-  initialState: TState;
-  steps: StepDef<TState>[];
-  storage?: StorageDriver;
-  retryPolicy?: { maxRetries: number; backoffMs: number };
-  eventBus?: EventBus;
-}
-
-export interface WorkflowResult<TState> {
-  state: TState;
-  stepResults: StepResult[];
-}
-
-export interface StepResult {
-  stepName: string;
-  status: "done" | "error" | "skipped";
-  error?: string;
-  durationMs: number;
-}

package/src/workflow/workflow.ts

@@ -1,68 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { EventBus } from "../events/event-bus.js";
-import { RunContext } from "../agent/run-context.js";
-import { StepRunner } from "./step-runner.js";
-import type { WorkflowConfig, WorkflowResult } from "./types.js";
-
-export class Workflow<
-  TState extends Record<string, unknown> = Record<string, unknown>,
-> {
-  readonly name: string;
-  readonly eventBus: EventBus;
-
-  private config: WorkflowConfig<TState>;
-  private stepRunner: StepRunner<TState>;
-
-  constructor(config: WorkflowConfig<TState>) {
-    this.config = config;
-    this.name = config.name;
-    this.eventBus = config.eventBus ?? new EventBus();
-    this.stepRunner = new StepRunner<TState>(config.retryPolicy);
-  }
-
-  async run(opts?: {
-    sessionId?: string;
-    userId?: string;
-  }): Promise<WorkflowResult<TState>> {
-    const ctx = new RunContext({
-      sessionId: opts?.sessionId ?? uuidv4(),
-      userId: opts?.userId,
-      eventBus: this.eventBus,
-      sessionState: {},
-    });
-
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: `workflow:${this.name}`,
-      input: JSON.stringify(this.config.initialState),
-    });
-
-    try {
-      const { state, results } = await this.stepRunner.executeSteps(
-        this.config.steps,
-        { ...this.config.initialState },
-        ctx
-      );
-
-      const workflowResult: WorkflowResult<TState> = {
-        state,
-        stepResults: results,
-      };
-
-      this.eventBus.emit("run.complete", {
-        runId: ctx.runId,
-        output: {
-          text: JSON.stringify(state),
-          toolCalls: [],
-          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        },
-      });
-
-      return workflowResult;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.eventBus.emit("run.error", { runId: ctx.runId, error: err });
-      throw err;
-    }
-  }
-}

package/tsconfig.json

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