elsium-ai 0.4.3 → 0.6.0

package/dist/index.d.ts

@@ -13,10 +13,10 @@ export { ElsiumError, ok, err, isOk, isErr, unwrap, unwrapOr, tryCatch, tryCatch
 export type { Role, ContentPart, TextContent, ImageContent, AudioContent, DocumentContent, Message, ToolCall, ToolResult, TokenUsage, CostBreakdown, StopReason, LLMResponse, StreamEvent, XRayData, StreamCheckpoint, ProviderConfig, CompletionRequest, ToolDefinition, TenantContext, Middleware, Result, Ok, Err, ElsiumStream, ResilientStreamOptions, LogLevel, Logger, ErrorCode, Registry, ContextStrategy, ContextManagerConfig, ContextManager, } from '@elsium-ai/core';
 export { gateway, registerProviderFactory, registerProvider, getProviderFactory, listProviders, registerProviderMetadata, getProviderMetadata, calculateCost, registerPricing, composeMiddleware, loggingMiddleware, costTrackingMiddleware, xrayMiddleware, createAnthropicProvider, createOpenAIProvider, createGoogleProvider, createProviderMesh, securityMiddleware, detectPromptInjection, detectJailbreak, redactSecrets, checkBlockedPatterns, cacheMiddleware, createInMemoryCache, outputGuardrailMiddleware, createBatch, } from '@elsium-ai/gateway';
 export type { LLMProvider, ProviderFactory, ProviderMetadata, ModelPricing, ModelTier, Gateway, GatewayConfig, XRayStore, ProviderMeshConfig, ProviderEntry, RoutingStrategy, ProviderMesh, SecurityMiddlewareConfig, SecurityViolation, SecurityResult, CacheAdapter, CacheStats, CacheMiddlewareConfig, OutputGuardrailConfig, OutputGuardrailRule, OutputViolation, BatchConfig, BatchResult, BatchResultItem, } from '@elsium-ai/gateway';
-export { defineAgent, runSequential, runParallel, runSupervisor, createMemory, createSemanticValidator, createAgentSecurity, createConfidenceScorer, executeStateMachine, createInMemoryMemoryStore, createSqliteMemoryStore, } from '@elsium-ai/agents';
-export type { Agent, AgentDependencies, AgentConfig, AgentResult, AgentRunOptions, GuardrailConfig, AgentHooks, Memory, MemoryConfig, SemanticGuardrailConfig, SemanticCheck, SemanticCheckResult, SemanticValidationResult, SemanticValidator, AgentSecurityConfig, AgentSecurityResult, ConfidenceConfig, ConfidenceResult, StateDefinition, StateHistoryEntry, StateMachineResult, MemoryStore, SqliteMemoryStoreConfig, } from '@elsium-ai/agents';
-export { defineTool, createToolkit, httpFetchTool, calculatorTool, jsonParseTool, currentTimeTool, formatToolResult, formatToolResultAsText, } from '@elsium-ai/tools';
-export type { Tool, ToolConfig, ToolContext, ToolExecutionResult, Toolkit, } from '@elsium-ai/tools';
+export { defineAgent, runSequential, runParallel, runSupervisor, createMemory, createSummarizeFn, createSemanticValidator, createAgentSecurity, createConfidenceScorer, executeStateMachine, createInMemoryMemoryStore, createSqliteMemoryStore, createAgentStream, createThread, loadThread, createInMemoryThreadStore, createAsyncAgent, createChannelGateway, createWebhookChannel, createSessionRouter, createScheduler, parseCronExpression, cronMatchesDate, getNextCronDate, } from '@elsium-ai/agents';
+export type { Agent, AgentDependencies, AgentGenerateResult, AgentConfig, AgentResult, AgentRunOptions, GuardrailConfig, AgentHooks, Memory, MemoryConfig, SummarizeFn, SemanticGuardrailConfig, SemanticCheck, SemanticCheckResult, SemanticValidationResult, SemanticValidator, AgentSecurityConfig, AgentSecurityResult, ConfidenceConfig, ConfidenceResult, StateDefinition, StateHistoryEntry, StateMachineResult, MemoryStore, SqliteMemoryStoreConfig, AgentStreamEvent, AgentStream, StreamingAgentDependencies, Thread, ThreadConfig, ThreadStore, ThreadSnapshot, ThreadSummary, AsyncAgent, AsyncAgentConfig, AsyncAgentRunOptions, AgentTask, TaskStatus, TaskProgressEvent, ChannelAdapter, ChannelGateway, ChannelGatewayConfig, IncomingMessage, OutgoingMessage, ChannelAttachment, WebhookChannelConfig, SessionRouter, SessionRouterConfig, SessionInfo, SessionResolveOptions, Scheduler, SchedulerConfig, ScheduleOptions, ScheduledTask, CronFields, } from '@elsium-ai/agents';
+export { defineTool, createToolkit, httpFetchTool, calculatorTool, jsonParseTool, currentTimeTool, formatToolResult, formatToolResultAsText, createRetrievalTool, } from '@elsium-ai/tools';
+export type { Tool, ToolConfig, ToolContext, ToolExecutionResult, Toolkit, RetrievalToolConfig, RetrievalResult as ToolRetrievalResult, RetrieveFn, } from '@elsium-ai/tools';
 export { rag, createInMemoryStore, createOpenAIEmbeddings, createMockEmbeddings, vectorStoreRegistry, embeddingProviderRegistry, createPgVectorStore, } from '@elsium-ai/rag';
 export type { RAGPipeline, RAGPipelineConfig, IngestResult, Document, Chunk, EmbeddedChunk, RetrievalResult, QueryOptions, EmbeddingProvider, VectorStore, VectorStoreFactory, EmbeddingProviderFactory, PgVectorStoreConfig, } from '@elsium-ai/rag';
 export { defineWorkflow, defineParallelWorkflow, defineBranchWorkflow, step, } from '@elsium-ai/workflows';

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -7858,6 +7858,35 @@ var currentTimeTool = defineTool({
     };
   }
 });
+// ../tools/src/retrieval.ts
+function defaultFormatResults(results) {
+  if (results.length === 0)
+    return "No relevant results found.";
+  return results.map((r, i) => {
+    const source = r.source ? ` (source: ${r.source})` : "";
+    return `[${i + 1}]${source} (score: ${r.score.toFixed(2)})
+${r.content}`;
+  }).join(`
+
+---
+
+`);
+}
+function createRetrievalTool(config) {
+  const topK = config.topK ?? 5;
+  const formatResult = config.formatResult ?? defaultFormatResults;
+  return defineTool({
+    name: config.name ?? "search_knowledge",
+    description: config.description ?? "Search the knowledge base for relevant information. Use this when you need to find facts, documentation, or context to answer questions.",
+    input: exports_external.object({
+      query: exports_external.string().describe("The search query to find relevant information")
+    }),
+    async handler(input) {
+      const results = await config.retrieve(input.query, { topK });
+      return formatResult(results);
+    }
+  });
+}
 // ../agents/src/approval.ts
 function createApprovalGate(config) {
   const timeoutMs = config.timeoutMs ?? 300000;
@@ -8036,6 +8065,35 @@ function createMemory(config) {
       messages.shift();
     }
   }
+  let summaryPending = false;
+  function needsSummarization() {
+    if (config.strategy !== "summary")
+      return false;
+    if (!config.summarize)
+      return false;
+    return messages.length > maxMessages;
+  }
+  async function runSummarization() {
+    if (summaryPending || !config.summarize)
+      return;
+    if (messages.length <= maxMessages)
+      return;
+    summaryPending = true;
+    try {
+      const keepCount = Math.floor(maxMessages / 2);
+      const toSummarize = messages.splice(0, messages.length - keepCount);
+      const summaryText = await config.summarize(toSummarize);
+      messages.unshift({
+        role: "system",
+        content: `[Conversation summary]: ${summaryText}`
+      });
+    } finally {
+      summaryPending = false;
+    }
+    if (config.store && config.agentId) {
+      config.store.save(config.agentId, [...messages]).catch(() => {});
+    }
+  }
   return {
     strategy: config.strategy,
     add(message) {
@@ -8047,6 +8105,8 @@ function createMemory(config) {
         case "token-limited":
           trimToTokenLimit();
           break;
+        case "summary":
+          break;
         case "unlimited":
           break;
       }
@@ -8077,9 +8137,28 @@ function createMemory(config) {
       if (!config.store || !config.agentId)
         return;
       await config.store.save(config.agentId, [...messages]);
+    },
+    async summarizeIfNeeded() {
+      if (needsSummarization()) {
+        await runSummarization();
+      }
     }
   };
 }
+var SUMMARIZE_SYSTEM = "You are a conversation summarizer. Given a conversation, produce a concise summary that preserves all key facts, decisions, user preferences, and context needed to continue the conversation. Be factual and complete. Do not add commentary.";
+function createSummarizeFn(complete) {
+  return async (messages) => {
+    const text = messages.map((m) => `${m.role}: ${extractText(m.content)}`).join(`
+`);
+    const response = await complete({
+      messages: [{ role: "user", content: `Summarize this conversation:
+
+${text}` }],
+      system: SUMMARIZE_SYSTEM
+    });
+    return extractText(response.message.content);
+  };
+}
 
 // ../agents/src/security.ts
 var INJECTION_PATTERNS2 = [
@@ -8670,6 +8749,219 @@ async function executeToolCalls(toolCalls, toolMap, history, signal, hooks, appr
   return results;
 }
 
+// ../agents/src/streaming.ts
+async function accumulateStreamedResponse(stream, emit) {
+  let textContent = "";
+  const toolCalls = [];
+  const toolArgBuffers = {};
+  let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+  let stopReason = "end_turn";
+  for await (const event of stream) {
+    switch (event.type) {
+      case "text_delta":
+        textContent += event.text;
+        emit({ type: "text_delta", text: event.text });
+        break;
+      case "tool_call_start":
+        toolArgBuffers[event.toolCall.id] = "";
+        toolCalls.push({ id: event.toolCall.id, name: event.toolCall.name, arguments: {} });
+        emit({ type: "tool_call_start", toolCall: event.toolCall });
+        break;
+      case "tool_call_delta":
+        if (toolArgBuffers[event.toolCallId] !== undefined) {
+          toolArgBuffers[event.toolCallId] += event.arguments;
+        }
+        emit({
+          type: "tool_call_delta",
+          toolCallId: event.toolCallId,
+          arguments: event.arguments
+        });
+        break;
+      case "tool_call_end": {
+        const tc = toolCalls.find((t) => t.id === event.toolCallId);
+        if (tc && toolArgBuffers[event.toolCallId]) {
+          try {
+            tc.arguments = JSON.parse(toolArgBuffers[event.toolCallId]);
+          } catch {
+            tc.arguments = {};
+          }
+        }
+        emit({ type: "tool_call_end", toolCallId: event.toolCallId });
+        break;
+      }
+      case "message_end":
+        usage = event.usage;
+        stopReason = event.stopReason;
+        break;
+    }
+  }
+  return {
+    message: {
+      role: "assistant",
+      content: textContent,
+      ...toolCalls.length ? { toolCalls } : {}
+    },
+    usage,
+    stopReason
+  };
+}
+async function executeStreamToolCalls(toolCalls, ctx, emit) {
+  const results = [];
+  const history = [];
+  for (const tc of toolCalls) {
+    const tool = ctx.toolMap.get(tc.name);
+    if (!tool) {
+      const errorResult = {
+        success: false,
+        error: `Unknown tool: ${tc.name}. Available: ${Array.from(ctx.toolMap.keys()).join(", ")}`,
+        toolCallId: tc.id,
+        durationMs: 0
+      };
+      emit({ type: "tool_result", toolCallId: tc.id, name: tc.name, result: errorResult });
+      history.push({ name: tc.name, arguments: tc.arguments, result: errorResult });
+      results.push(formatToolResult(errorResult));
+      continue;
+    }
+    const result = await tool.execute(tc.arguments, {
+      toolCallId: tc.id,
+      signal: ctx.options.signal
+    });
+    emit({ type: "tool_result", toolCallId: tc.id, name: tc.name, result });
+    history.push({ name: tc.name, arguments: tc.arguments, result });
+    results.push(formatToolResult(result));
+  }
+  return {
+    toolMessage: { role: "tool", content: "", toolResults: results },
+    history
+  };
+}
+function createAgentStream(messages, ctx) {
+  let resolveResult;
+  let rejectResult;
+  const resultPromise = new Promise((resolve2, reject) => {
+    resolveResult = resolve2;
+    rejectResult = reject;
+  });
+  const events = [];
+  let resolve = null;
+  let done = false;
+  function emit(event) {
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: event, done: false });
+    } else {
+      events.push(event);
+    }
+  }
+  function finish() {
+    done = true;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: undefined, done: true });
+    }
+  }
+  runStreamLoop(messages, ctx, emit).then((agentResult) => {
+    resolveResult(agentResult);
+    finish();
+  }).catch((err2) => {
+    const error = err2 instanceof Error ? err2 : new Error(String(err2));
+    emit({ type: "error", error });
+    rejectResult?.(error);
+    finish();
+  });
+  resultPromise.catch(() => {});
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          const next = events.shift();
+          if (next) {
+            return Promise.resolve({ value: next, done: false });
+          }
+          if (done) {
+            return Promise.resolve({ value: undefined, done: true });
+          }
+          return new Promise((r) => {
+            resolve = r;
+          });
+        }
+      };
+    },
+    result() {
+      return resultPromise;
+    }
+  };
+  return iterable;
+}
+async function runStreamLoop(messages, ctx, emit) {
+  const { config, deps, memory, options } = ctx;
+  const traceId = options.traceId ?? generateTraceId();
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const totalCost = 0;
+  let iterations = 0;
+  const allToolCalls = [];
+  const scopedMessages = [...memory.getMessages()];
+  const conversationMessages = [...scopedMessages, ...messages];
+  while (iterations < ctx.maxIterations) {
+    iterations++;
+    if (options.signal?.aborted) {
+      throw new ElsiumError({
+        code: "VALIDATION_ERROR",
+        message: `Agent "${config.name}" was aborted`,
+        retryable: false
+      });
+    }
+    if (totalInputTokens + totalOutputTokens > ctx.maxTokenBudget) {
+      throw ElsiumError.budgetExceeded(totalInputTokens + totalOutputTokens, ctx.maxTokenBudget);
+    }
+    emit({ type: "iteration_start", iteration: iterations });
+    const request = {
+      messages: conversationMessages,
+      model: config.model,
+      system: config.system,
+      tools: config.tools?.map((t) => t.toDefinition())
+    };
+    const llmStream = deps.stream(request);
+    const { message, usage, stopReason } = await accumulateStreamedResponse(llmStream, emit);
+    totalInputTokens += usage.inputTokens;
+    totalOutputTokens += usage.outputTokens;
+    conversationMessages.push(message);
+    if (!message.toolCalls?.length || stopReason !== "tool_use") {
+      emit({ type: "iteration_end", iteration: iterations });
+      for (const msg of conversationMessages.slice(scopedMessages.length)) {
+        memory.add(msg);
+      }
+      const agentResult = {
+        message,
+        usage: {
+          totalInputTokens,
+          totalOutputTokens,
+          totalTokens: totalInputTokens + totalOutputTokens,
+          totalCost,
+          iterations
+        },
+        toolCalls: allToolCalls,
+        traceId
+      };
+      emit({ type: "agent_end", result: agentResult });
+      return agentResult;
+    }
+    const { toolMessage, history } = await executeStreamToolCalls(message.toolCalls, ctx, emit);
+    allToolCalls.push(...history);
+    conversationMessages.push(toolMessage);
+    emit({ type: "iteration_end", iteration: iterations });
+  }
+  throw new ElsiumError({
+    code: "MAX_ITERATIONS",
+    message: `Agent "${config.name}" reached maximum iterations (${ctx.maxIterations})`,
+    retryable: false,
+    metadata: { iterations, maxIterations: ctx.maxIterations }
+  });
+}
+
 // ../agents/src/agent.ts
 async function safeHook2(fn) {
   if (!fn)
@@ -8683,7 +8975,10 @@ function resolveDependencies(config, deps) {
     return deps;
   if (typeof config.provider === "object" && config.provider !== null) {
     const provider = config.provider;
-    return { complete: (req) => provider.complete(req) };
+    return {
+      complete: (req) => provider.complete(req),
+      stream: (req) => provider.stream(req)
+    };
   }
   if (!config.provider || !config.apiKey) {
     throw ElsiumError.validation("Either provide AgentDependencies as second argument, set provider and apiKey in config, or pass an LLMProvider object as provider");
@@ -8694,7 +8989,10 @@ function resolveDependencies(config, deps) {
     baseUrl: config.baseUrl,
     model: config.model
   });
-  return { complete: (req) => gw.complete(req) };
+  return {
+    complete: (req) => gw.complete(req),
+    stream: (req) => gw.stream(req)
+  };
 }
 function defineAgent(config, deps) {
   const resolvedDeps = resolveDependencies(config, deps);
@@ -8934,6 +9232,51 @@ function defineAgent(config, deps) {
       const userMessage = { role: "user", content: input };
       return executeLoop([userMessage], options);
     },
+    async generate(input, schema, options = {}) {
+      validateInputText(input);
+      const jsonSchema = zodToJsonSchema(schema);
+      const schemaInstruction = [
+        "You MUST respond with valid JSON matching this schema:",
+        JSON.stringify(jsonSchema, null, 2),
+        "Respond ONLY with the JSON object, no markdown or explanation."
+      ].join(`
+`);
+      const augmentedInput = `${input}
+
+${schemaInstruction}`;
+      const userMessage = { role: "user", content: augmentedInput };
+      const agentResult = await executeLoop([userMessage], options);
+      const text = extractText(agentResult.message.content);
+      const cleaned = text.replace(/^```(?:json)?\s*\n?([\s\S]*?)\n?\s*```$/gm, "$1").trim();
+      const jsonMatch = cleaned.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+      if (!jsonMatch) {
+        throw ElsiumError.validation("Agent response did not contain valid JSON");
+      }
+      const parsed = schema.safeParse(JSON.parse(jsonMatch[0]));
+      if (!parsed.success) {
+        throw ElsiumError.validation("Agent response did not match schema", {
+          errors: parsed.error.issues
+        });
+      }
+      return { data: parsed.data, result: agentResult };
+    },
+    stream(input, options = {}) {
+      validateInputText(input);
+      const streamDeps = resolvedDeps;
+      if (!streamDeps.stream) {
+        throw ElsiumError.validation("Streaming requires a stream function in agent dependencies. " + "Pass { complete, stream } or use a provider that supports streaming.");
+      }
+      const userMessage = { role: "user", content: input };
+      return createAgentStream([userMessage], {
+        config,
+        deps: streamDeps,
+        memory,
+        toolMap,
+        options,
+        maxIterations: guardrails.maxIterations,
+        maxTokenBudget: guardrails.maxTokenBudget
+      });
+    },
     async chat(messages, options = {}) {
       for (const msg of messages) {
         if (msg.role !== "user")
@@ -9130,6 +9473,698 @@ async function runSupervisor(supervisor, workers, input, options) {
   };
   return supervisor.run(supervisorInput, agentOptions);
 }
+// ../agents/src/thread.ts
+function createThread(config) {
+  const id = config.id ?? generateId("thread");
+  const messages = [];
+  const metadata = { ...config.metadata };
+  const createdAt = Date.now();
+  let updatedAt = createdAt;
+  function addMessage(message) {
+    messages.push(message);
+    updatedAt = Date.now();
+    if (config.store) {
+      config.store.save({
+        id,
+        messages: [...messages],
+        createdAt,
+        updatedAt,
+        metadata
+      }).catch(() => {});
+    }
+  }
+  return {
+    id,
+    metadata,
+    async send(input, options = {}) {
+      const userMessage = { role: "user", content: input };
+      addMessage(userMessage);
+      const result = await config.agent.chat([...messages], options);
+      addMessage(result.message);
+      return result;
+    },
+    stream(input, options = {}) {
+      const userMessage = { role: "user", content: input };
+      addMessage(userMessage);
+      const agentStream = config.agent.stream(input, options);
+      const originalResult = agentStream.result.bind(agentStream);
+      const wrappedStream = {
+        [Symbol.asyncIterator]() {
+          const inner = agentStream[Symbol.asyncIterator]();
+          return {
+            async next() {
+              const iterResult = await inner.next();
+              if (!iterResult.done && iterResult.value.type === "agent_end") {
+                addMessage(iterResult.value.result.message);
+              }
+              return iterResult;
+            }
+          };
+        },
+        async result() {
+          const r = await originalResult();
+          return r;
+        }
+      };
+      return wrappedStream;
+    },
+    getMessages() {
+      return [...messages];
+    },
+    addMessage(message) {
+      addMessage(message);
+    },
+    fork(options) {
+      const forked = createThread({
+        id: options?.id,
+        agent: config.agent,
+        metadata: { ...metadata, forkedFrom: id },
+        store: config.store
+      });
+      for (const msg of messages) {
+        forked.addMessage({ ...msg });
+      }
+      return forked;
+    },
+    clear() {
+      messages.length = 0;
+      updatedAt = Date.now();
+    },
+    async save() {
+      if (!config.store)
+        return;
+      await config.store.save({
+        id,
+        messages: [...messages],
+        createdAt,
+        updatedAt,
+        metadata
+      });
+    }
+  };
+}
+async function loadThread(threadId, config) {
+  const snapshot = await config.store.load(threadId);
+  if (!snapshot)
+    return null;
+  const thread = createThread({
+    id: threadId,
+    agent: config.agent,
+    metadata: snapshot.metadata,
+    store: config.store
+  });
+  for (const msg of snapshot.messages) {
+    thread.addMessage(msg);
+  }
+  return thread;
+}
+function createInMemoryThreadStore() {
+  const store = new Map;
+  return {
+    async load(threadId) {
+      const snapshot = store.get(threadId);
+      if (!snapshot)
+        return null;
+      return { ...snapshot, messages: [...snapshot.messages] };
+    },
+    async save(snapshot) {
+      store.set(snapshot.id, { ...snapshot, messages: [...snapshot.messages] });
+    },
+    async delete(threadId) {
+      store.delete(threadId);
+    },
+    async list(options) {
+      const limit = options?.limit ?? 50;
+      const offset = options?.offset ?? 0;
+      const entries = [...store.values()].sort((a, b) => b.updatedAt - a.updatedAt).slice(offset, offset + limit);
+      return entries.map((s) => {
+        const lastMsg = s.messages[s.messages.length - 1];
+        const lastMessage = lastMsg ? typeof lastMsg.content === "string" ? lastMsg.content.slice(0, 100) : undefined : undefined;
+        return {
+          id: s.id,
+          messageCount: s.messages.length,
+          createdAt: s.createdAt,
+          updatedAt: s.updatedAt,
+          lastMessage,
+          metadata: s.metadata
+        };
+      });
+    }
+  };
+}
+// ../agents/src/async-agent.ts
+function createAsyncAgent(config) {
+  const tasks = new Map;
+  function emitProgress(task, event) {
+    try {
+      config.onProgress?.(toPublicTask(task), event);
+    } catch {}
+  }
+  function toPublicTask(task) {
+    return {
+      id: task.id,
+      agentName: task.agentName,
+      input: task.input,
+      status: task.status,
+      result: task.result,
+      error: task.error,
+      createdAt: task.createdAt,
+      startedAt: task.startedAt,
+      completedAt: task.completedAt,
+      metadata: task.metadata,
+      cancel() {
+        if (task.status === "pending" || task.status === "running") {
+          task.status = "cancelled";
+          task.completedAt = Date.now();
+          task.abortController.abort();
+          emitProgress(task, { type: "cancelled", taskId: task.id });
+          task.reject(new ElsiumError({
+            code: "VALIDATION_ERROR",
+            message: `Task ${task.id} was cancelled`,
+            retryable: false
+          }));
+        }
+      },
+      wait() {
+        return task.promise;
+      }
+    };
+  }
+  async function executeTask(task) {
+    task.status = "running";
+    task.startedAt = Date.now();
+    emitProgress(task, { type: "started", taskId: task.id });
+    try {
+      const result = await config.agent.run(task.input, {
+        signal: task.abortController.signal,
+        traceId: task.metadata.traceId
+      });
+      if (task.status === "cancelled")
+        return;
+      task.status = "completed";
+      task.result = result;
+      task.completedAt = Date.now();
+      emitProgress(task, { type: "completed", taskId: task.id, result });
+      try {
+        config.onComplete?.(toPublicTask(task));
+      } catch {}
+      task.resolve(result);
+    } catch (err2) {
+      if (task.status === "cancelled")
+        return;
+      const error = err2 instanceof Error ? err2 : new Error(String(err2));
+      task.status = "failed";
+      task.error = error;
+      task.completedAt = Date.now();
+      emitProgress(task, { type: "failed", taskId: task.id, error });
+      try {
+        config.onError?.(toPublicTask(task), error);
+      } catch {}
+      task.reject(error);
+    }
+  }
+  return {
+    submit(input, options = {}) {
+      const taskId = options.taskId ?? generateId("task");
+      const abortController = new AbortController;
+      if (options.signal) {
+        options.signal.addEventListener("abort", () => abortController.abort(), { once: true });
+      }
+      let resolvePromise;
+      let rejectPromise;
+      const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+      });
+      const task = {
+        id: taskId,
+        agentName: config.agent.name,
+        input,
+        status: "pending",
+        result: null,
+        error: null,
+        createdAt: Date.now(),
+        startedAt: null,
+        completedAt: null,
+        metadata: { ...options.metadata },
+        abortController,
+        promise,
+        resolve: resolvePromise,
+        reject: rejectPromise
+      };
+      tasks.set(taskId, task);
+      executeTask(task);
+      return toPublicTask(task);
+    },
+    getTask(taskId) {
+      const task = tasks.get(taskId);
+      return task ? toPublicTask(task) : null;
+    },
+    listTasks(filter) {
+      const all = [...tasks.values()];
+      const filtered = filter?.status ? all.filter((t) => t.status === filter.status) : all;
+      return filtered.map(toPublicTask);
+    },
+    cancelAll() {
+      for (const task of tasks.values()) {
+        if (task.status === "pending" || task.status === "running") {
+          task.status = "cancelled";
+          task.completedAt = Date.now();
+          task.abortController.abort();
+          emitProgress(task, { type: "cancelled", taskId: task.id });
+          task.reject(new ElsiumError({
+            code: "VALIDATION_ERROR",
+            message: `Task ${task.id} was cancelled`,
+            retryable: false
+          }));
+        }
+      }
+    }
+  };
+}
+// ../agents/src/channels.ts
+function createWebhookChannel(config) {
+  let messageHandler = null;
+  return {
+    name: config.name,
+    async start() {},
+    async stop() {},
+    async send(userId, message) {
+      await config.onSend?.(userId, message);
+    },
+    onMessage(handler) {
+      messageHandler = handler;
+    },
+    receive(message) {
+      if (!messageHandler)
+        return;
+      messageHandler({ ...message, channelName: config.name });
+    }
+  };
+}
+function createChannelGateway(config) {
+  const adapterMap = new Map;
+  for (const adapter of config.adapters) {
+    if (adapter.name === "__proto__" || adapter.name === "constructor" || adapter.name === "prototype")
+      continue;
+    adapterMap.set(adapter.name, adapter);
+  }
+  function findAdapter(channelName) {
+    return adapterMap.get(channelName);
+  }
+  async function handleIncoming(message) {
+    const agent = config.resolveAgent?.(message) ?? config.agent;
+    try {
+      const session = await config.router.resolve({
+        channelName: message.channelName,
+        userId: message.userId,
+        agent
+      });
+      const result = await session.send(message.text);
+      const responseText = typeof result.message.content === "string" ? result.message.content : "";
+      const adapter = findAdapter(message.channelName);
+      if (adapter && responseText) {
+        await adapter.send(message.userId, { text: responseText });
+      }
+    } catch (err2) {
+      const error = err2 instanceof Error ? err2 : new Error(String(err2));
+      try {
+        config.onError?.(error, message);
+      } catch {}
+    }
+  }
+  for (const adapter of config.adapters) {
+    adapter.onMessage(handleIncoming);
+  }
+  return {
+    adapters: adapterMap,
+    async start() {
+      const startPromises = [...adapterMap.values()].map((a) => a.start());
+      await Promise.all(startPromises);
+    },
+    async stop() {
+      const stopPromises = [...adapterMap.values()].map((a) => a.stop());
+      await Promise.all(stopPromises);
+    }
+  };
+}
+// ../agents/src/session.ts
+function sessionKey(channelName, userId) {
+  return `${channelName}::${userId}`;
+}
+function createSessionRouter(config) {
+  const sessions = new Map;
+  const concurrency = config.concurrency ?? "serial";
+  const sessionTimeout = config.sessionTimeout ?? 0;
+  let cleanupTimer = null;
+  if (sessionTimeout > 0) {
+    cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [key, session] of sessions) {
+        if (now - session.lastActiveAt > sessionTimeout) {
+          sessions.delete(key);
+          try {
+            config.onSessionExpired?.({
+              sessionId: session.sessionId,
+              channelName: session.channelName,
+              userId: session.userId,
+              agentName: session.agent.name,
+              createdAt: session.createdAt,
+              lastActiveAt: session.lastActiveAt
+            });
+          } catch {}
+        }
+      }
+    }, Math.min(sessionTimeout, 60000));
+    if (typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+      cleanupTimer.unref();
+    }
+  }
+  function toPublicSession(session) {
+    return {
+      sessionId: session.sessionId,
+      channelName: session.channelName,
+      userId: session.userId,
+      agentName: session.agent.name,
+      createdAt: session.createdAt,
+      lastActiveAt: session.lastActiveAt
+    };
+  }
+  async function createNewSession(key, channelName, userId, agent) {
+    const sessionId = generateId("sess");
+    const threadId = `${channelName}-${userId}-${sessionId}`;
+    let thread = null;
+    if (config.store) {
+      thread = await loadThread(threadId, { agent, store: config.store });
+    }
+    if (!thread) {
+      thread = createThread({
+        id: threadId,
+        agent,
+        metadata: { channelName, userId, sessionId },
+        store: config.store
+      });
+    }
+    const now = Date.now();
+    const session = {
+      sessionId,
+      channelName,
+      userId,
+      agent,
+      thread,
+      createdAt: now,
+      lastActiveAt: now,
+      lock: null,
+      lockResolve: null
+    };
+    sessions.set(key, session);
+    try {
+      config.onSessionCreated?.(toPublicSession(session));
+    } catch {}
+    return session;
+  }
+  function wrapThreadWithConcurrency(session) {
+    if (concurrency !== "serial")
+      return session.thread;
+    const originalSend = session.thread.send.bind(session.thread);
+    return {
+      ...session.thread,
+      async send(input, options) {
+        while (session.lock) {
+          await session.lock;
+        }
+        let unlock;
+        session.lock = new Promise((resolve) => {
+          unlock = resolve;
+        });
+        session.lockResolve = unlock;
+        try {
+          const result = await originalSend(input, options);
+          session.lastActiveAt = Date.now();
+          return result;
+        } finally {
+          session.lock = null;
+          session.lockResolve = null;
+          unlock();
+        }
+      }
+    };
+  }
+  return {
+    async resolve(options) {
+      const agent = options.agent ?? config.defaultAgent;
+      const key = sessionKey(options.channelName, options.userId);
+      let session = sessions.get(key);
+      if (session && sessionTimeout > 0) {
+        const now = Date.now();
+        if (now - session.lastActiveAt > sessionTimeout) {
+          sessions.delete(key);
+          try {
+            config.onSessionExpired?.(toPublicSession(session));
+          } catch {}
+          session = undefined;
+        }
+      }
+      if (!session) {
+        session = await createNewSession(key, options.channelName, options.userId, agent);
+      }
+      session.lastActiveAt = Date.now();
+      return wrapThreadWithConcurrency(session);
+    },
+    getSession(channelName, userId) {
+      const session = sessions.get(sessionKey(channelName, userId));
+      return session ? toPublicSession(session) : null;
+    },
+    listSessions() {
+      return [...sessions.values()].map(toPublicSession);
+    },
+    endSession(channelName, userId) {
+      return sessions.delete(sessionKey(channelName, userId));
+    },
+    endAllSessions() {
+      sessions.clear();
+      if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+      }
+    }
+  };
+}
+// ../agents/src/scheduler.ts
+function parseCronExpression(expression) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5)
+    return null;
+  const minute = parseCronField(parts[0], 0, 59);
+  const hour = parseCronField(parts[1], 0, 23);
+  const dayOfMonth = parseCronField(parts[2], 1, 31);
+  const month = parseCronField(parts[3], 1, 12);
+  const dayOfWeek = parseCronField(parts[4], 0, 6);
+  if (!minute || !hour || !dayOfMonth || !month || !dayOfWeek)
+    return null;
+  return { minute, hour, dayOfMonth, month, dayOfWeek };
+}
+function parseStepPart(match, min, max) {
+  const step = Number.parseInt(match[2], 10);
+  if (step <= 0)
+    return null;
+  let rangeStart = min;
+  let rangeEnd = max;
+  if (match[1] !== "*") {
+    const rangeParts = match[1].split("-");
+    rangeStart = Number.parseInt(rangeParts[0], 10);
+    rangeEnd = rangeParts[1] ? Number.parseInt(rangeParts[1], 10) : max;
+  }
+  const values = [];
+  for (let i = rangeStart;i <= rangeEnd; i += step) {
+    if (i >= min && i <= max)
+      values.push(i);
+  }
+  return values;
+}
+function parseRangePart(match, min, max) {
+  const start = Number.parseInt(match[1], 10);
+  const end = Number.parseInt(match[2], 10);
+  if (start > end || start < min || end > max)
+    return null;
+  const values = [];
+  for (let i = start;i <= end; i++) {
+    values.push(i);
+  }
+  return values;
+}
+function parseSinglePart(part, min, max) {
+  const stepMatch = part.match(/^(\*|\d+(?:-\d+)?)\/(\d+)$/);
+  if (stepMatch)
+    return parseStepPart(stepMatch, min, max);
+  const rangeMatch = part.match(/^(\d+)-(\d+)$/);
+  if (rangeMatch)
+    return parseRangePart(rangeMatch, min, max);
+  const num = Number.parseInt(part, 10);
+  if (Number.isNaN(num) || num < min || num > max)
+    return null;
+  return [num];
+}
+function parseCronField(field, min, max) {
+  if (field === "*") {
+    return Array.from({ length: max - min + 1 }, (_, i) => min + i);
+  }
+  const values = [];
+  for (const part of field.split(",")) {
+    const result = parseSinglePart(part, min, max);
+    if (!result)
+      return null;
+    values.push(...result);
+  }
+  return values.length > 0 ? values : null;
+}
+function cronMatchesDate(fields, date) {
+  return fields.minute.includes(date.getMinutes()) && fields.hour.includes(date.getHours()) && fields.dayOfMonth.includes(date.getDate()) && fields.month.includes(date.getMonth() + 1) && fields.dayOfWeek.includes(date.getDay());
+}
+function getNextCronDate(fields, after) {
+  const next = new Date(after.getTime());
+  next.setSeconds(0, 0);
+  next.setMinutes(next.getMinutes() + 1);
+  const maxIterations = 525600;
+  for (let i = 0;i < maxIterations; i++) {
+    if (cronMatchesDate(fields, next))
+      return next;
+    next.setMinutes(next.getMinutes() + 1);
+  }
+  return next;
+}
+function createScheduler(config) {
+  const tasks = new Map;
+  let timer = null;
+  const tickInterval = config.tickIntervalMs ?? 60000;
+  function toPublicTask(task) {
+    return {
+      id: task.id,
+      name: task.name,
+      cronExpression: task.cronExpression,
+      enabled: task.enabled,
+      lastRunAt: task.lastRunAt,
+      nextRunAt: task.nextRunAt,
+      runCount: task.runCount
+    };
+  }
+  function updateNextRun(task) {
+    const fields = parseCronExpression(task.cronExpression);
+    task.nextRunAt = fields ? getNextCronDate(fields, new Date).getTime() : null;
+  }
+  function handleTaskSuccess(task, result) {
+    task.lastRunAt = Date.now();
+    task.runCount++;
+    task.running = false;
+    if (task.maxRuns !== null && task.runCount >= task.maxRuns) {
+      task.enabled = false;
+      task.nextRunAt = null;
+    } else {
+      updateNextRun(task);
+    }
+    try {
+      config.onComplete?.(toPublicTask(task), result);
+    } catch {}
+  }
+  function handleTaskError(task, err2) {
+    task.running = false;
+    task.lastRunAt = Date.now();
+    updateNextRun(task);
+    const error = err2 instanceof Error ? err2 : new Error(String(err2));
+    try {
+      config.onError?.(toPublicTask(task), error);
+    } catch {}
+  }
+  async function executeTask(task) {
+    if (task.running)
+      return;
+    task.running = true;
+    const agent = config.resolveAgent?.(toPublicTask(task)) ?? config.agent;
+    try {
+      const result = await agent.run(task.input);
+      handleTaskSuccess(task, result);
+    } catch (err2) {
+      handleTaskError(task, err2);
+    }
+  }
+  function tick() {
+    const now = Date.now();
+    for (const task of tasks.values()) {
+      if (!task.enabled || task.running)
+        continue;
+      if (task.nextRunAt !== null && task.nextRunAt <= now) {
+        executeTask(task);
+      }
+    }
+  }
+  return {
+    schedule(cronExpression, input, options = {}) {
+      const fields = parseCronExpression(cronExpression);
+      if (!fields) {
+        throw new Error(`Invalid cron expression: ${cronExpression}`);
+      }
+      const id = options.id ?? generateId("sched");
+      const now = new Date;
+      const nextRunAt = options.startImmediately ? Date.now() : getNextCronDate(fields, now).getTime();
+      const task = {
+        id,
+        name: options.name ?? `task-${id}`,
+        cronExpression,
+        input,
+        enabled: true,
+        lastRunAt: null,
+        nextRunAt,
+        runCount: 0,
+        maxRuns: options.maxRuns ?? null,
+        metadata: options.metadata ?? {},
+        running: false
+      };
+      tasks.set(id, task);
+      if (options.startImmediately) {
+        executeTask(task);
+      }
+      return toPublicTask(task);
+    },
+    unschedule(taskId) {
+      return tasks.delete(taskId);
+    },
+    getTask(taskId) {
+      const task = tasks.get(taskId);
+      return task ? toPublicTask(task) : null;
+    },
+    listTasks() {
+      return [...tasks.values()].map(toPublicTask);
+    },
+    pause(taskId) {
+      const task = tasks.get(taskId);
+      if (!task)
+        return false;
+      task.enabled = false;
+      return true;
+    },
+    resume(taskId) {
+      const task = tasks.get(taskId);
+      if (!task)
+        return false;
+      task.enabled = true;
+      const fields = parseCronExpression(task.cronExpression);
+      task.nextRunAt = fields ? getNextCronDate(fields, new Date).getTime() : null;
+      return true;
+    },
+    start() {
+      if (timer)
+        return;
+      tick();
+      timer = setInterval(tick, tickInterval);
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+  };
+}
 // ../rag/src/loaders.ts
 function createDocument(content, metadata) {
   return {
@@ -15230,11 +16265,13 @@ export {
   redactSecrets,
   rag,
   parseTraceparent,
+  parseCronExpression,
   outputGuardrailMiddleware,
   ok,
   observe,
   mockProvider,
   loggingMiddleware,
+  loadThread,
   loadFixture,
   listProviders,
   jsonParseTool,
@@ -15244,6 +16281,7 @@ export {
   httpFetchTool,
   getProviderMetadata,
   getProviderFactory,
+  getNextCronDate,
   generateTraceId,
   generateId,
   gateway,
@@ -15268,12 +16306,19 @@ export {
   defineBranchWorkflow,
   defineAgent,
   currentTimeTool,
+  cronMatchesDate,
+  createWebhookChannel,
   createToolkit,
+  createThread,
+  createSummarizeFn,
   createStream,
   createSqliteMemoryStore,
   createSpan,
   createSnapshotStore,
+  createSessionRouter,
   createSemanticValidator,
+  createScheduler,
+  createRetrievalTool,
   createReplayRecorder,
   createReplayPlayer,
   createRegressionSuite,
@@ -15291,6 +16336,7 @@ export {
   createMCPServer,
   createMCPClient,
   createLogger,
+  createInMemoryThreadStore,
   createInMemoryStore,
   createInMemoryMemoryStore,
   createInMemoryCache,
@@ -15301,9 +16347,12 @@ export {
   createContextManager,
   createConfidenceScorer,
   createClient,
+  createChannelGateway,
   createBatch,
+  createAsyncAgent,
   createApp,
   createAnthropicProvider,
+  createAgentStream,
   createAgentSecurity,
   countTokens,
   costTrackingMiddleware,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "elsium-ai",
-	"version": "0.4.3",
+	"version": "0.6.0",
 	"description": "ElsiumAI — A high-performance, TypeScript-first AI framework",
 	"license": "MIT",
 	"author": "Eric Utrera <ebutrera9103@gmail.com>",
@@ -25,17 +25,17 @@
 		"build": "bun build ./src/index.ts --outdir ./dist --target node && bun x tsc -p tsconfig.build.json --emitDeclarationOnly"
 	},
 	"dependencies": {
-		"@elsium-ai/core": "^0.4.3",
-		"@elsium-ai/gateway": "^0.4.3",
-		"@elsium-ai/agents": "^0.4.3",
-		"@elsium-ai/tools": "^0.4.3",
-		"@elsium-ai/rag": "^0.4.3",
-		"@elsium-ai/workflows": "^0.4.3",
-		"@elsium-ai/observe": "^0.4.3",
-		"@elsium-ai/app": "^0.4.3",
-		"@elsium-ai/testing": "^0.4.3",
-		"@elsium-ai/mcp": "^0.4.3",
-		"@elsium-ai/client": "^0.4.3"
+		"@elsium-ai/core": "^0.6.0",
+		"@elsium-ai/gateway": "^0.6.0",
+		"@elsium-ai/agents": "^0.6.0",
+		"@elsium-ai/tools": "^0.6.0",
+		"@elsium-ai/rag": "^0.6.0",
+		"@elsium-ai/workflows": "^0.6.0",
+		"@elsium-ai/observe": "^0.6.0",
+		"@elsium-ai/app": "^0.6.0",
+		"@elsium-ai/testing": "^0.6.0",
+		"@elsium-ai/mcp": "^0.6.0",
+		"@elsium-ai/client": "^0.6.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.7.0"