@alneas/eaos-server 0.0.0-stage → 0.2.0

package/dist/agentic/ai-broker.d.ts

@@ -0,0 +1,169 @@
+import { AIExecutionDecision, AgentJobRecord, AIExecutionRequest, AgentJobKind, AIExecutionCandidate } from '@alneas/eaos-core';
+import { AtomicSession } from '../plugin-data/index.js';
+import { ServerAgentTaskRequest, ServerAgentExecutionContext, ServerAgentWorkerType, ServerAgentDispatchMode } from './types.js';
+import 'hono/types';
+import '@alneas/eaos-core/plugin-sdk';
+import 'hono';
+import '@alneas/eaos-server/lifecycle-engine';
+
+/**
+ * Host-advertised AI candidate with server worker and queue/local-runner delivery binding.
+ * @see DurableAIExecutionBroker.
+ */
+interface ServerAIExecutionRoute extends AIExecutionCandidate {
+    /** Executor key bound to the selected host route. */
+    workerType: ServerAgentWorkerType;
+    /** Local CLI/MLX candidates must use local-pull; nonlocal candidates cannot use local-pull. */
+    dispatchMode: ServerAgentDispatchMode;
+    /** Pin a route to one registered local runner when the host requires it. */
+    runnerId?: string;
+}
+/**
+ * Verified task input before the broker chooses immutable runtime routing fields.
+ * @see DurableAIExecutionBroker.plan.
+ */
+interface AIJobTaskInput {
+    /** Stable task identifier. */
+    id: string;
+    /** Verified tenant, required to match routing context. */
+    tenantId: string;
+    /** Verified user, required to match routing context. */
+    userId: string;
+    /** Human task label forwarded to runtime. */
+    title: string;
+    /** Runtime instructions forwarded without domain validation here. */
+    instructions: string;
+    /** Optional domain execution context. */
+    context?: Record<string, unknown>;
+    /** Optional workflow/tool context; broker-owned routing fields are replaced. */
+    executionContext?: ServerAgentExecutionContext;
+    /** Optional runtime timeout in milliseconds, forwarded for executor validation. */
+    timeoutMs?: number;
+}
+/**
+ * Verified routing request, task, and queue deduplication/retry metadata.
+ * @see DurableAIExecutionBroker.plan.
+ */
+interface AIJobSubmission {
+    /** Core execution requirements and verified context used for route allocation. */
+    routing: AIExecutionRequest;
+    /** Verified task before worker/routing binding. */
+    task: AIJobTaskInput;
+    /** Queue job kind and idempotency partition. */
+    kind: AgentJobKind;
+    /** Optional associated workflow instance. */
+    workflowInstanceId?: string;
+    /** Optional queue correlation ID; defaults to routing.context.operation. */
+    correlationId?: string;
+    /** Optional durable deduplication key; absent uses task execution key then task.id. */
+    idempotencyKey?: string;
+    /** Optional job attempt ceiling; defaults to 5 through createAgentJob. */
+    maxAttempts?: number;
+}
+/**
+ * Selected runtime decision and unpersisted or saved queue job.
+ * @see DurableAIExecutionBroker.enqueue.
+ */
+interface AIJobPlan {
+    /** Current selector decision, even when enqueue returns an existing deduplicated job. */
+    decision: AIExecutionDecision;
+    /** Created or deduplicated queue record with persisted runtime routing. */
+    job: AgentJobRecord<ServerAgentTaskRequest>;
+}
+/**
+ * Micro2 controller for dynamic model/runtime allocation.
+ *
+ * It selects only host-advertised routes and persists the selected route in
+ * the durable job. It never reads a subscription credential or starts a local
+ * process. A local-pull route is later claimed by LocalRunnerPullCoordinator.
+ * @remarks Route selection and planning are process-local. The host verifies identity and supplies current candidate availability/policy; authorization, runtime execution, and safe retries remain separate responsibilities.
+ * @example
+ * ```typescript
+ * import { DurableAIExecutionBroker } from "@alneas/eaos-server/agentic/ai-broker";
+ * export function broker(options: ConstructorParameters<typeof DurableAIExecutionBroker>[0]) {
+ *   return new DurableAIExecutionBroker(options);
+ * }
+ * ```
+ */
+declare class DurableAIExecutionBroker {
+    private readonly routesById;
+    private readonly selector;
+    private readonly now;
+    /**
+     * Validates and clones server routes and configures the core allocation selector.
+     * @param options - Nonempty routes list; optional policyVersion labels selector decisions and now supplies job timestamps, defaulting to fresh Date.
+     * @throws Invalid/missing routes, incompatible local dispatch bindings, core selector validation, or clone failures.
+     */
+    constructor(options: {
+        /**
+         * Nonempty host-approved execution routes, validated/cloned before configuring the selector; route IDs and runtime dispatch bindings must be compatible.
+         */
+        routes: readonly ServerAIExecutionRoute[];
+        /**
+         * Optional decision policy label forwarded to the Core selector; omission selects ai-execution-policy-v1.
+         */
+        policyVersion?: string;
+        /**
+         * Optional clock used when constructing agent job records; omission creates a new current Date per call.
+         * @returns A valid Date used for planned job timestamps; clock failures propagate from planning.
+         * @see {@link DurableAIExecutionBroker.plan}
+         */
+        now?: () => Date;
+    });
+    /**
+     * Lists registered server route bindings without exposing mutable stored objects.
+     * @returns Cloned route records in registration map order.
+     * @example
+     * ```typescript
+     * import { DurableAIExecutionBroker } from "@alneas/eaos-server/agentic/ai-broker";
+     * export function routes(broker: DurableAIExecutionBroker) { return broker.listRoutes(); }
+     * ```
+     */
+    listRoutes(): readonly ServerAIExecutionRoute[];
+    /**
+     * Selects an eligible host-advertised runtime using the core routing policy.
+     * @param request - Verified AI execution requirements and context.
+     * @returns The core selector decision; no job is persisted or runtime started.
+     * @throws Propagates core routing validation/no-eligible-route errors.
+     * @example
+     * ```typescript
+     * import { DurableAIExecutionBroker } from "@alneas/eaos-server/agentic/ai-broker";
+     * import type { AIExecutionRequest } from "@alneas/eaos-core";
+     * export function decide(broker: DurableAIExecutionBroker, request: AIExecutionRequest) { return broker.decide(request); }
+     * ```
+     */
+    decide(request: AIExecutionRequest): AIExecutionDecision;
+    /**
+     * Selects a route and creates a queue record with host-controlled worker/dispatch/runner bindings.
+     * @param input - Routing and task must have matching tenantId/userId; queue metadata follows AIJobSubmission.
+     * @returns Decision and newly created job; caller-supplied broker route/dispatch/runner execution fields are stripped before selected bindings are written.
+     * @throws Principal mismatch, unavailable route, invalid core routing, clone/hash/clock, or job creation failures.
+     * @remarks No persistence or deduplication occurs until enqueue; repeated plan calls generate different job IDs.
+     * @example
+     * ```typescript
+     * import { DurableAIExecutionBroker } from "@alneas/eaos-server/agentic/ai-broker";
+     * import type { AIJobSubmission } from "@alneas/eaos-server/agentic/ai-broker";
+     * export function plan(broker: DurableAIExecutionBroker, input: AIJobSubmission) { return broker.plan(input); }
+     * ```
+     */
+    plan(input: AIJobSubmission): AIJobPlan;
+    /**
+     * Plans routing and atomically inserts or deduplicates the queue job in a caller-owned session.
+     * @param tx - Authorized atomic transaction/session; caller owns commit/rollback.
+     * @param input - Verified routing/task and queue metadata.
+     * @returns Decision plus the newly saved or existing idempotent job.
+     * @throws Planning errors, conflicting deduplication input, corrupt index, or session failures.
+     * @remarks Selection still runs before deduplication; the returned existing job is authoritative for its persisted routing. No runtime execution occurs.
+     * @example
+     * ```typescript
+     * import { DurableAIExecutionBroker } from "@alneas/eaos-server/agentic/ai-broker";
+     * import type { AIJobSubmission } from "@alneas/eaos-server/agentic/ai-broker";
+     * import type { AtomicSession } from "@alneas/eaos-server/plugin-data/atomic";
+     * export async function enqueue(broker: DurableAIExecutionBroker, tx: AtomicSession, input: AIJobSubmission) { return broker.enqueue(tx, input); }
+     * ```
+     */
+    enqueue(tx: AtomicSession, input: AIJobSubmission): Promise<AIJobPlan>;
+}
+
+export { DurableAIExecutionBroker };
+export type { AIJobPlan, AIJobSubmission, AIJobTaskInput, ServerAIExecutionRoute };

package/dist/agentic/ai-broker.js

@@ -0,0 +1,8 @@
+import {
+  DurableAIExecutionBroker
+} from "../chunk-LYPZPE53.js";
+import "../chunk-PBC3MZUL.js";
+export {
+  DurableAIExecutionBroker
+};
+//# sourceMappingURL=ai-broker.js.map

package/dist/agentic/ai-broker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agentic/atomic-checkpointer.d.ts

@@ -0,0 +1,137 @@
+import { BaseCheckpointSaver, CheckpointTuple, Checkpoint, CheckpointMetadata } from '@langchain/langgraph';
+import { AtomicRepository, PluginPrincipal } from '../plugin-data/index.js';
+import '@alneas/eaos-core';
+import 'hono/types';
+import '@alneas/eaos-core/plugin-sdk';
+import 'hono';
+import '@alneas/eaos-server/lifecycle-engine';
+
+type Config = Parameters<BaseCheckpointSaver['getTuple']>[0];
+type ListOptions = Parameters<BaseCheckpointSaver['list']>[1];
+type Writes = Parameters<BaseCheckpointSaver['putWrites']>[1];
+/**
+ * Stores LangGraph checkpoints and pending writes in an existing scoped atomic repository.
+ * @remarks Admission and workflow writer serialization remain host-owned. Each saver instance serializes repository work through an internal Promise chain and calls verifyCurrent before the transaction and before/after its work. This does not serialize other saver instances or whole graph invocations. The repository owns durability/CAS; this saver installs no timers and does not close host storage. Checkpoint erasure requires a separate host retention executor.
+ * @example
+ * ```typescript
+ * import { AtomicCheckpointSaver } from "@alneas/eaos-server/agentic/atomic-checkpointer";
+ * export function saver(options: ConstructorParameters<typeof AtomicCheckpointSaver>[0]) {
+ *   return new AtomicCheckpointSaver(options);
+ * }
+ * ```
+ */
+declare class AtomicCheckpointSaver extends BaseCheckpointSaver {
+    private readonly options;
+    private readonly principal;
+    private pending;
+    /**
+     * Captures a verified plugin principal and required current-admission callback.
+     * @param options - Scoped repository; principal is validated/cloned; verifyCurrent must reject on revoked admission; prefix defaults to graph-checkpoint and must contain 1–64 lowercase letters/digits/underscore/hyphen.
+     * @throws Invalid principal, absent repository/verifier, invalid prefix, or clone failure.
+     */
+    constructor(options: {
+        /**
+         * Connected host atomic repository used for scoped checkpoint and pending-write transactions; this saver does not close it.
+         */
+        repository: AtomicRepository;
+        /**
+         * Verified plugin principal validated and cloned at construction; fixes the tenant/plugin/user scope used for repository transactions.
+         */
+        principal: PluginPrincipal;
+        /**
+         * Recheck current host admission before repository work and at transaction boundaries.
+         * @returns No value; resolve only while the captured principal remains admitted and reject when admission is revoked.
+         * @remarks Required callback; called before the repository transaction and before/after its work, and before each history yield. The host owns the live policy lookup.
+         * @see {@link AtomicCheckpointSaver}
+         */
+        verifyCurrent: () => Promise<void>;
+        /**
+         * Optional repository key prefix; defaults to graph-checkpoint and must contain 1–64 lowercase letters, digits, underscores or hyphens.
+         */
+        prefix?: string;
+    });
+    private scope;
+    private config;
+    private encode;
+    private decode;
+    private run;
+    private tuple;
+    /**
+     * Reads one scoped checkpoint and its separately stored pending writes.
+     * @param config - LangGraph config with required thread_id, optional checkpoint_ns (default empty), and optional checkpoint_id (default latest lexicographic ID). Identifiers are bounded to 512 characters without control characters.
+     * @returns Decoded checkpoint tuple or undefined if no selected checkpoint exists.
+     * @throws Rejects invalid identifiers, tenant/thread/namespace or format mismatch, and admission/repository/serialization failures.
+     * @example
+     * ```typescript
+     * import { AtomicCheckpointSaver } from "@alneas/eaos-server/agentic/atomic-checkpointer";
+     * export async function read(saver: AtomicCheckpointSaver, config: Parameters<AtomicCheckpointSaver["getTuple"]>[0]) { return saver.getTuple(config); }
+     * ```
+     */
+    getTuple(config: Config): Promise<CheckpointTuple | undefined>;
+    /**
+     * Lists scoped checkpoint history in descending lexicographic checkpoint-ID order.
+     * @param config - Required thread scope, optional namespace, and optional exact checkpoint ID filter.
+     * @param options - limit defaults to 100 and must be a safe integer 1–2000; before must use the same thread/namespace and excludes its ID and newer IDs; filter compares metadata fields by atomic hash.
+     * @returns Async sequence of decoded tuples, possibly empty, with admission rechecked before each yield.
+     * @throws Iteration rejects invalid scope/limits, more than 2000 scanned checkpoint rows, identity/format mismatch, or admission/repository/serialization errors.
+     * @remarks History is collected in a bounded repository transaction before yielding; changing authorization can still stop later yields.
+     * @example
+     * ```typescript
+     * import { AtomicCheckpointSaver } from "@alneas/eaos-server/agentic/atomic-checkpointer";
+     * export async function history(saver: AtomicCheckpointSaver, config: Parameters<AtomicCheckpointSaver["list"]>[0]) {
+     *   const tuples = [];
+     *   for await (const tuple of saver.list(config, { limit: 10 })) tuples.push(tuple);
+     *   return tuples;
+     * }
+     * ```
+     */
+    list(config: Config, options?: ListOptions): AsyncGenerator<CheckpointTuple>;
+    /**
+     * Writes an immutable version-4 checkpoint and advances the scoped latest pointer when its ID sorts later.
+     * @param config - Thread/namespace scope; optional checkpoint_id becomes the new checkpoint's parent ID.
+     * @param checkpoint - Current LangGraph version-4 checkpoint with valid nonempty bounded ID.
+     * @param metadata - Serializer-supported checkpoint metadata.
+     * @returns A config selecting the stored checkpoint ID.
+     * @throws Rejects unsupported format, ID reuse with different content, admission/CAS/repository errors, or serialization failures.
+     * @remarks Repeating identical content is accepted; latest ordering is lexicographic, so host checkpoint IDs must reflect desired chronology.
+     * @example
+     * ```typescript
+     * import { AtomicCheckpointSaver } from "@alneas/eaos-server/agentic/atomic-checkpointer";
+     * export async function write(saver: AtomicCheckpointSaver, ...args: Parameters<AtomicCheckpointSaver["put"]>) { return saver.put(...args); }
+     * ```
+     */
+    put(config: Config, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<Config>;
+    /**
+     * Merges pending channel writes by task/index for one scoped checkpoint.
+     * @param config - Thread/namespace with required checkpoint_id.
+     * @param writes - At most 256 channel/value pairs; channels are valid bounded identifiers. Ordinary task/index duplicates retain their first value; reserved negative-index channels replace prior values.
+     * @param taskId - Nonempty bounded task identifier associating writes.
+     * @returns No value; resolves after the merged writes are durably stored.
+     * @throws Rejects missing checkpoint ID, invalid task/channel, identity mismatch, more than 2000 stored pending writes, or admission/repository/serialization errors.
+     * @example
+     * ```typescript
+     * import { AtomicCheckpointSaver } from "@alneas/eaos-server/agentic/atomic-checkpointer";
+     * export async function writePending(saver: AtomicCheckpointSaver, ...args: Parameters<AtomicCheckpointSaver["putWrites"]>) { await saver.putWrites(...args); }
+     * ```
+     */
+    putWrites(config: Config, writes: Writes, taskId: string): Promise<void>;
+    /**
+     * Rejects thread deletion because this repository contract provides no approved erasure operation.
+     * @param _threadId - Requested thread ID; not read or deleted.
+     * @returns No value; this operation always rejects before performing storage work.
+     * @throws Always rejects with an error directing the caller to the host retention executor.
+     * @example
+     * ```typescript
+     * import { AtomicCheckpointSaver } from "@alneas/eaos-server/agentic/atomic-checkpointer";
+     * export async function erase(saver: AtomicCheckpointSaver, threadId: string) {
+     *   try { await saver.deleteThread(threadId); } catch (error) {
+     *     // Host retention tooling must perform reviewed erasure.
+     *     throw error;
+     *   }
+     * }
+     * ```
+     */
+    deleteThread(_threadId: string): Promise<void>;
+}
+
+export { AtomicCheckpointSaver };

package/dist/agentic/atomic-checkpointer.js

@@ -0,0 +1,9 @@
+import {
+  AtomicCheckpointSaver
+} from "../chunk-3NLSWP2Y.js";
+import "../chunk-INCHXAFK.js";
+import "../chunk-3VITSHN3.js";
+export {
+  AtomicCheckpointSaver
+};
+//# sourceMappingURL=atomic-checkpointer.js.map

package/dist/agentic/atomic-checkpointer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/agentic/autonomous-worker.d.ts

@@ -0,0 +1,122 @@
+import { AIChatAdapter } from '@alneas/appkit-core/ai/ai-chat';
+import { ChatClientOptions } from '../execution/index.js';
+import { McpGatekeeper, AgentRuntimeResourcePolicy } from '@alneas/eaos-core';
+import { ServerAgentWorkerType, ServerAgentExecutor, ServerAgentTaskRequest, ServerAgentTaskResult } from './types.js';
+import '@alneas/appkit-core/ai/action';
+import 'hono/types';
+import 'hono';
+import '@alneas/appkit-core/ai';
+
+/**
+ * Host composition of the shared chat path for built-in model tasks.
+ * @remarks Defaults retain the worker gatekeeper, 60-second task timeout and worker output bound. Tools are undisclosed; action orchestration belongs to createToolAgent. No model transport or credential is selected from model output.
+ * @see ServerWorkerOptions for complete worker configuration.
+ */
+interface ServerWorkerChatOptions extends Omit<ChatClientOptions, 'adapter' | 'authorize' | 'tools'> {
+    /** Optional host adapter; omission uses Appkit's OpenAI-compatible LiteLLM transport. */
+    adapter?: AIChatAdapter;
+    /** Optional live Host authorization, combined with the worker gatekeeper before and after asynchronous work. */
+    authorize?: ChatClientOptions['authorize'];
+}
+/**
+ * Trusted gatekeeper, runtime endpoints/adapters, and execution limits for {@link ServerAutonomousWorker}.
+ */
+interface ServerWorkerOptions {
+    /** Host security/approval policies; defaults to a new McpGatekeeper. */
+    gatekeeper?: McpGatekeeper;
+    /** Trusted executable path; defaults to GOOSE_BIN_PATH or goose. */
+    gooseBinaryPath?: string;
+    /** Trusted executable path; defaults to HERMES_AGENT_BIN_PATH or hermes. */
+    hermesAgentBinaryPath?: string;
+    /** Host LiteLLM base URL; defaults to LITELLM_ENDPOINT or http://localhost:4000/v1. */
+    litellmEndpoint?: string;
+    /** Host model identifier; defaults to LITELLM_MODEL and is required for built-in LiteLLM execution. */
+    litellmModel?: string;
+    /** Host-owned provider headers; captured at construction and never read from task/model input. */
+    litellmHeaders?: Readonly<Record<string, string>>;
+    /** Optional shared chat model routing, live authorization, limits, guards, usage, budget and observability. */
+    chat?: ServerWorkerChatOptions;
+    /** Combined command output/string result ceiling, safe integer 1–10000000; defaults to 1000000. */
+    maxOutputChars?: number;
+    /** Framework default is safe for the ARM agent host. Host adapters may tighten it. */
+    runtimePolicy?: AgentRuntimeResourcePolicy;
+    /** Built-in Goose/Hermes execution is permitted only on the AI placement. */
+    runtimeRole?: ServerRuntimeRole;
+    /** Host fetch implementation for built-in LiteLLM; defaults to global fetch. */
+    fetch?: typeof fetch;
+    /** Host/plugin adapters for coding agents and other external runtimes. */
+    executors?: Partial<Record<ServerAgentWorkerType, ServerAgentExecutor>>;
+}
+/**
+ * Host placement role controlling whether built-in Goose/Hermes processes may run locally.
+ * @see ServerAutonomousWorker.
+ */
+type ServerRuntimeRole = 'edge' | 'application-worker' | 'ai';
+/**
+ * Admits and executes host agent tasks through a gatekeeper and bounded runtime adapters.
+ * @remarks This class runs only when runTask is called; it installs no scheduler. The host authenticates tenant/user claims before admission. Framework-managed tasks share a per-instance concurrency counter; injected executors own scheduling and are exempt from it. Built-in Goose/Hermes require the ai role and Node process/systemd support. Queue persistence, approvals, retries, and side-effect idempotency belong to the host.
+ * @example
+ * ```typescript
+ * import { ServerAutonomousWorker, type ServerWorkerOptions } from "@alneas/eaos-server/agentic/autonomous-worker";
+ * export function worker(options: ServerWorkerOptions) { return new ServerAutonomousWorker(options); }
+ * ```
+ */
+declare class ServerAutonomousWorker {
+    private gatekeeper;
+    private goosePath;
+    private hermesAgentPath;
+    private litellmUrl;
+    private litellmModel?;
+    private litellmHeaders;
+    private chatOptions;
+    private maxOutputChars;
+    private runtimePolicy;
+    private runtimeRole;
+    private activeTasks;
+    private fetchImpl;
+    private executors;
+    /**
+     * Captures runtime settings and validates resource policy, role, and output ceiling.
+     * @param options - Trusted host configuration; omitted gatekeeper uses a new McpGatekeeper and runtime role uses EAOS_RUNTIME_ROLE, then ai on arm64 or application-worker otherwise.
+     * @throws Invalid resource policy, role, or output limit.
+     */
+    constructor(options?: ServerWorkerOptions);
+    /**
+     * Checks task limits and gatekeeper policy before dispatching one runtime attempt.
+     * @param request - Verified task identity and instructions; required strings must be nonblank, title at most 500 characters, instructions at most 1000000, and timeout a safe integer 1–3600000 milliseconds when provided.
+     * @param execution - Optional cancellation signal for built-in shared chat tasks; does not change injected executor or process contracts.
+     * @returns COMPLETED text output, PENDING_APPROVAL ticket data without execution, or FAILED data with error and optional classification/retry advice. Duration is measured in wall-clock milliseconds.
+     * @throws Can reject a throwing gatekeeper or malformed gatekeeper interaction before dispatch; runtime execution errors are normally returned as FAILED data.
+     * @remarks Gatekeeper receives fixed agent/server_bot roles rather than request user roles. Approval tickets are generated but not persisted here. The configured framework policy overrides request.runtimePolicy before execution. Injected executors and built-in chat outputs are bounded by maxOutputChars. LiteLLM uses Appkit SSE transport through createChatClient; JSON-only endpoints require a Host adapter or executor. Existing FAILED/PENDING_APPROVAL/COMPLETED envelopes and injected-executor priority remain unchanged.
+     * @example
+     * ```typescript
+     * import { ServerAutonomousWorker, type ServerWorkerOptions } from "@alneas/eaos-server/agentic/autonomous-worker";
+     * import type { ServerAgentTaskRequest } from "@alneas/eaos-server/agentic/types";
+     * export async function execute(options: ServerWorkerOptions, request: ServerAgentTaskRequest) {
+     *   return new ServerAutonomousWorker(options).runTask(request);
+     * }
+     * ```
+     */
+    runTask(request: ServerAgentTaskRequest, execution?: {
+        /** Cooperatively cancel built-in shared chat. Injected executors and Goose/Hermes retain their own cancellation contracts. */
+        signal?: AbortSignal;
+    }): Promise<ServerAgentTaskResult>;
+    private execute;
+    /**
+     * Execute Goose in headless batch mode
+     */
+    private executeHeadlessGoose;
+    /**
+     * Execute NousResearch Hermes Agent in headless mode (-z / non-interactive)
+     * Hermes Agent provides persistent cross-session memory and self-improving skill extraction.
+     */
+    private executeHeadlessHermesAgent;
+    /**
+     * Execute a host-selected model through LiteLLM.
+     */
+    private executeLiteLlm;
+    private boundOutput;
+}
+
+export { ServerAutonomousWorker };
+export type { ServerRuntimeRole, ServerWorkerChatOptions, ServerWorkerOptions };

package/dist/agentic/autonomous-worker.js

@@ -0,0 +1,10 @@
+import {
+  ServerAutonomousWorker
+} from "../chunk-F2J6IQ6I.js";
+import "../chunk-YMHVRBUU.js";
+import "../chunk-32746UQZ.js";
+import "../chunk-YABTQZDJ.js";
+export {
+  ServerAutonomousWorker
+};
+//# sourceMappingURL=autonomous-worker.js.map

package/dist/agentic/autonomous-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}