arcie 0.1.3 → 0.1.5

package/dist/index-CElLRVTP.d.ts

@@ -0,0 +1,136 @@
+import { n as TurnContext } from './types-DwxwdSa2.js';
+import { StreamEvent } from './protocol/events.js';
+
+interface MemoryEntry {
+    role: "user" | "assistant" | "tool" | "system";
+    content: string;
+    timestamp: number;
+    turnId?: string;
+    score?: number;
+}
+interface Thread {
+    id: string;
+    resourceId: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+}
+interface DeleteMessagesOptions {
+    threadId: string;
+    resourceId: string;
+    messageIds?: string[];
+    beforeTimestamp?: number;
+    afterTimestamp?: number;
+}
+interface MemoryQuery {
+    resourceId: string;
+    threadId: string;
+    query?: string;
+    limit?: number;
+}
+interface RecallOptions {
+    threadId: string;
+    resourceId: string;
+    page?: number;
+    perPage?: number;
+    dateRange?: {
+        start?: Date;
+        end?: Date;
+    };
+    include?: Array<{
+        id: string;
+        withPreviousMessages?: number;
+        withNextMessages?: number;
+    }>;
+    vectorSearchString?: string;
+}
+interface RecallResult {
+    messages: MemoryEntry[];
+    total: number;
+    hasMore: boolean;
+}
+interface MemoryStore {
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    search?(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    close?(): Promise<void>;
+    createThread?(thread: Thread): Promise<void>;
+    getThread?(threadId: string, resourceId: string): Promise<Thread | null>;
+    listThreads?(resourceId: string): Promise<Thread[]>;
+    updateThread?(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread?(threadId: string, resourceId: string): Promise<void>;
+    deleteMessages?(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread?(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+interface MemoryStrategy {
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+interface InputProcessor {
+    name: string;
+    processInput(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+}
+interface MemoryProcessor extends InputProcessor {
+    processOutput?(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+interface Embedder {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    readonly dimensions: number;
+}
+interface VectorStore {
+    upsert(namespace: string, vectors: Array<{
+        id: string;
+        values: number[];
+        metadata?: Record<string, unknown>;
+    }>): Promise<void>;
+    query(namespace: string, vector: number[], options?: {
+        topK?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<Array<{
+        id: string;
+        score: number;
+        metadata?: Record<string, unknown>;
+    }>>;
+    delete(namespace: string, ids: string[]): Promise<void>;
+}
+
+interface RunOptions {
+    endpoint?: string;
+    apiKey?: string;
+    maxTurns?: number;
+    sessionId?: string;
+    resourceId?: string;
+    threadId?: string;
+    memoryStore?: MemoryStore;
+    onEvent?: (event: StreamEvent) => void;
+}
+interface RunResult {
+    output: string;
+    turns: TurnContext[];
+    events: StreamEvent[];
+    sessionId: string;
+}
+declare function runAgent(agentDir: string, input: string, options?: RunOptions): Promise<RunResult>;
+declare function streamAgent(agentDir: string, input: string, options?: RunOptions): AsyncGenerator<StreamEvent, void, unknown>;
+
+export { type DeleteMessagesOptions as D, type Embedder as E, type MemoryStore as M, type RecallOptions as R, type Thread as T, type VectorStore as V, type MemoryEntry as a, type MemoryStrategy as b, type MemoryProcessor as c, type RecallResult as d, type MemoryQuery as e, type RunOptions as f, type RunResult as g, runAgent as r, streamAgent as s };

package/dist/index.d.ts

@@ -1,18 +1,297 @@
-export { defineAgent } from "./agent/index.js";
-export { defineInstructions, loadInstructions } from "./instructions/index.js";
-export { defineTool } from "./tools/index.js";
-export { defineSkill, getSkill } from "./skills/index.js";
-export { defineHook } from "./hooks/index.js";
-export { defineChannel, POST, GET } from "./channels/index.js";
-export { defineSchedule } from "./schedules/index.js";
-export { getSession, getTurn, getContext, requireContext, hasContext, setContext, ensureContext } from "./context/index.js";
-export { loadAgent } from "./loader.js";
-export { runAgent, streamAgent } from "./runner/index.js";
-export { discoverAgent } from "./discover/index.js";
-export { bearer, basic } from "./auth/index.js";
-export type { OutboundAuthFn, TokenValue } from "./auth/index.js";
-export type * from "./types.js";
-export type * from "./protocol/events.js";
-export { createSessionStarted, createTurnStarted, createMessageReceived, createMessageAppended, createMessageCompleted, createStepStarted, createStepCompleted, createTurnCompleted, createSessionWaiting, createSessionCompleted, encodeEvent, encodeEvents, } from "./protocol/events.js";
-export type { StreamEvent } from "./protocol/events.js";
-//# sourceMappingURL=index.d.ts.map
+export { defineAgent } from './agent/index.js';
+export { defineInstructions, loadInstructions } from './instructions/index.js';
+export { defineTool, toModelOutput } from './tools/index.js';
+export { defineSkill, getSkill } from './skills/index.js';
+export { defineHook } from './hooks/index.js';
+export { GET, POST, defineChannel } from './channels/index.js';
+import { C as ConnectionConfig, T as ToolConfig, S as SessionConfig, A as AgentManifest } from './types-DwxwdSa2.js';
+export { a as AgentConfig, b as ApprovalStrategy, c as CencoriConfig, d as ChannelConfig, e as ChannelRequest, f as ChannelResponse, H as HookConfig, g as HookEvent, h as HookPayload, I as InstructionsConfig, P as PolicyConfig, i as ScheduleConfig, j as Session, k as SkillConfig, l as SubagentManifest, m as ToolCallContext, n as TurnContext } from './types-DwxwdSa2.js';
+export { defineSchedule } from './schedules/index.js';
+export { ensureContext, getContext, getSession, getTurn, hasContext, requireContext, setContext, setSession, setTurn } from './context/index.js';
+import { M as MemoryStore, a as MemoryEntry, T as Thread, D as DeleteMessagesOptions, b as MemoryStrategy, c as MemoryProcessor, E as Embedder, V as VectorStore, R as RecallOptions, d as RecallResult } from './index-CElLRVTP.js';
+export { e as MemoryQuery, r as runAgent, s as streamAgent } from './index-CElLRVTP.js';
+export { discoverAgent } from './discover/index.js';
+export { OutboundAuthFn, TokenValue, basic, bearer } from './auth/index.js';
+export { ActionResultError, ActionResultStatus, AssistantStepFinishReason, MessageAppendedEvent, MessageCompletedEvent, MessageReceivedEvent, ReasoningAppendedEvent, ReasoningCompletedEvent, SessionCompletedEvent, SessionFailedEvent, SessionStartedEvent, SessionWaitingEvent, StepCompletedEvent, StepFailedEvent, StepStartedEvent, StreamEvent, SubagentCalledEvent, SubagentCompletedEvent, ToolCallCompletedEvent, ToolCallStartedEvent, TurnCompletedEvent, TurnFailedEvent, TurnStartedEvent, createMessageAppended, createMessageCompleted, createMessageReceived, createReasoningAppended, createReasoningCompleted, createSessionCompleted, createSessionFailed, createSessionStarted, createSessionWaiting, createStepCompleted, createStepFailed, createStepStarted, createSubagentCalled, createSubagentCompleted, createToolCallCompleted, createToolCallStarted, createTurnCompleted, createTurnFailed, createTurnStarted, encodeEvent, encodeEvents } from './protocol/events.js';
+import 'zod';
+
+declare function defineConnection(config: ConnectionConfig): ConnectionConfig;
+
+declare class InMemoryStore implements MemoryStore {
+    private entries;
+    private threads;
+    private key;
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    search(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    close(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, _resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, _resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+
+declare class SqliteStore implements MemoryStore {
+    private client;
+    constructor(dbPath?: string);
+    private init;
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    search(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    close(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, _resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, _resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+
+declare class FileStore implements MemoryStore {
+    private baseDir;
+    constructor(baseDir?: string);
+    private filePath;
+    private threadsPath;
+    private read;
+    private write;
+    private readThreads;
+    private writeThreads;
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    close(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+
+interface CencoriMemoryClient {
+    store(options: {
+        namespace: string;
+        content: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    search(options: {
+        namespace: string;
+        query: string;
+        limit?: number;
+        threshold?: number;
+        filter?: Record<string, unknown>;
+    }): Promise<{
+        results: Array<{
+            content: string;
+            metadata: Record<string, unknown>;
+            similarity?: number;
+        }>;
+    }>;
+    delete?(options: {
+        namespace: string;
+        ids?: string[];
+        filter?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+declare class CencoriMemoryStore implements MemoryStore {
+    private client;
+    constructor(client: CencoriMemoryClient);
+    save(resourceId: string, threadId: string, entries: MemoryEntry[]): Promise<void>;
+    load(resourceId: string, threadId: string, limit?: number): Promise<MemoryEntry[]>;
+    clear(resourceId: string, threadId: string): Promise<void>;
+    search(resourceId: string, threadId: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    close(): Promise<void>;
+    createThread(_thread: Thread): Promise<void>;
+    getThread(_threadId: string, _resourceId: string): Promise<Thread | null>;
+    listThreads(_resourceId: string): Promise<Thread[]>;
+    updateThread(_thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(_threadId: string, _resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+}
+
+declare class LastNStrategy implements MemoryStrategy {
+    private limit;
+    constructor(limit?: number);
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+
+declare class KeyFactsStrategy implements MemoryStrategy {
+    private facts;
+    private loaded;
+    private ensureLoaded;
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, _toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+
+type SummarizeFn = (text: string) => Promise<string>;
+declare class SummaryStrategy implements MemoryStrategy {
+    private limit;
+    private summary;
+    private summarize;
+    private mutex;
+    constructor(limit?: number, summarize?: SummarizeFn);
+    private exclusive;
+    private defaultSummarize;
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+
+declare class SemanticRecall implements MemoryStrategy {
+    private topK;
+    constructor(topK?: number);
+    getInputContext(store: MemoryStore, resourceId: string, threadId: string): Promise<string>;
+    recordTurn(store: MemoryStore, resourceId: string, threadId: string, input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+
+declare const DEFAULT_TEMPLATE = "# User Profile\n\n- **Name**:\n- **Interests**:\n- **Goals**:\n- **Preferences**:\n";
+declare const WORKING_MEMORY_SYSTEM_INSTRUCTION = "You have access to a persistent working memory that stores information about the user.\nYou can read the current working memory below and update it using the `updateWorkingMemory` tool.\n\nWhen the user tells you something about themselves, update the working memory to reflect it.\nUse the `updateWorkingMemory` tool with `section` set to the markdown heading (e.g. \"Interests\") and `content` set to the new bullet list content for that section.";
+declare class WorkingMemory implements MemoryStrategy {
+    private template;
+    private content;
+    private baseDir;
+    private resourceId;
+    private initialized;
+    constructor(template?: string, baseDir?: string, resourceId?: string);
+    private ensureDir;
+    private filePath;
+    private loadFromDisk;
+    private saveToDisk;
+    getSystemInstruction(): string;
+    getCurrentContent(resourceId: string): string;
+    updateSection(resourceId: string, section: string, content: string): void;
+    getToolDefinitions(): Record<string, ToolConfig>;
+    getInputContext(_store: MemoryStore, resourceId: string, _threadId: string): Promise<string>;
+    recordTurn(_store: MemoryStore, _resourceId: string, _threadId: string, _input: string, _output: string, _toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+}
+
+interface MemoryOptions {
+    store?: MemoryStore;
+    resourceId?: string;
+    threadId?: string;
+    processors?: (MemoryProcessor | MemoryStrategy)[];
+    embedder?: Embedder;
+    vectorStore?: VectorStore;
+    lastMessages?: number;
+    readOnly?: boolean;
+}
+declare class Memory {
+    store: MemoryStore;
+    resourceId: string;
+    threadId: string;
+    private processors;
+    private readOnly;
+    private buildSource;
+    constructor(options?: MemoryOptions);
+    constructor(config: SessionConfig["memory"], options?: MemoryOptions);
+    private buildFromConfig;
+    /**
+     * Create a new Memory instance sharing the same store and configuration
+     * but with overridden resourceId, threadId, and/or readOnly.
+     * Useful for per-request memory config.
+     */
+    with(overrides: {
+        resourceId?: string;
+        threadId?: string;
+        readOnly?: boolean;
+    }): Memory;
+    destroy(): Promise<void>;
+    getInputContext(): Promise<string>;
+    getSystemInstruction(): string;
+    getToolDefinitions(): Record<string, ToolConfig>;
+    recordTurn(input: string, output: string, toolCalls?: {
+        tool: string;
+        input: unknown;
+        output: unknown;
+    }[]): Promise<void>;
+    clear(): Promise<void>;
+    createThread(thread: Thread): Promise<void>;
+    getThread(threadId: string, resourceId: string): Promise<Thread | null>;
+    listThreads(resourceId: string): Promise<Thread[]>;
+    updateThread(thread: Partial<Thread> & {
+        id: string;
+        resourceId: string;
+    }): Promise<void>;
+    deleteThread(threadId: string, resourceId: string): Promise<void>;
+    deleteMessages(opts: DeleteMessagesOptions): Promise<number>;
+    cloneThread(source: {
+        threadId: string;
+        resourceId: string;
+    }, dest: {
+        threadId: string;
+        resourceId: string;
+    }): Promise<void>;
+    recall(opts: RecallOptions): Promise<RecallResult>;
+}
+
+interface LoadedAgent {
+    manifest: AgentManifest;
+    agentDir: string;
+}
+declare function loadAgent(agentDir: string): Promise<LoadedAgent>;
+
+export { AgentManifest, type CencoriMemoryClient, CencoriMemoryStore, ConnectionConfig, DEFAULT_TEMPLATE, FileStore, InMemoryStore, KeyFactsStrategy, LastNStrategy, Memory, MemoryEntry, MemoryStore, MemoryStrategy, SemanticRecall, SessionConfig, SqliteStore, type SummarizeFn, SummaryStrategy, ToolConfig, WORKING_MEMORY_SYSTEM_INSTRUCTION, WorkingMemory, defineConnection, loadAgent };

package/dist/index.js

@@ -1,14 +1,161 @@
-export { defineAgent } from "./agent/index.js";
-export { defineInstructions, loadInstructions } from "./instructions/index.js";
-export { defineTool } from "./tools/index.js";
-export { defineSkill, getSkill } from "./skills/index.js";
-export { defineHook } from "./hooks/index.js";
-export { defineChannel, POST, GET } from "./channels/index.js";
-export { defineSchedule } from "./schedules/index.js";
-export { getSession, getTurn, getContext, requireContext, hasContext, setContext, ensureContext } from "./context/index.js";
-export { loadAgent } from "./loader.js";
-export { runAgent, streamAgent } from "./runner/index.js";
-export { discoverAgent } from "./discover/index.js";
-export { bearer, basic } from "./auth/index.js";
-export { createSessionStarted, createTurnStarted, createMessageReceived, createMessageAppended, createMessageCompleted, createStepStarted, createStepCompleted, createTurnCompleted, createSessionWaiting, createSessionCompleted, encodeEvent, encodeEvents, } from "./protocol/events.js";
+import {
+  defineAgent
+} from "./chunk-FQ7KDNV5.js";
+import {
+  basic,
+  bearer
+} from "./chunk-CKHBEZCT.js";
+import {
+  CencoriMemoryStore,
+  DEFAULT_TEMPLATE,
+  FileStore,
+  InMemoryStore,
+  KeyFactsStrategy,
+  LastNStrategy,
+  Memory,
+  SemanticRecall,
+  SqliteStore,
+  SummaryStrategy,
+  WORKING_MEMORY_SYSTEM_INSTRUCTION,
+  WorkingMemory,
+  runAgent,
+  streamAgent
+} from "./chunk-4WSILP75.js";
+import {
+  loadAgent
+} from "./chunk-KVSX4MLK.js";
+import {
+  discoverAgent
+} from "./chunk-6XETPLIF.js";
+import {
+  createMessageAppended,
+  createMessageCompleted,
+  createMessageReceived,
+  createReasoningAppended,
+  createReasoningCompleted,
+  createSessionCompleted,
+  createSessionFailed,
+  createSessionStarted,
+  createSessionWaiting,
+  createStepCompleted,
+  createStepFailed,
+  createStepStarted,
+  createSubagentCalled,
+  createSubagentCompleted,
+  createToolCallCompleted,
+  createToolCallStarted,
+  createTurnCompleted,
+  createTurnFailed,
+  createTurnStarted,
+  encodeEvent,
+  encodeEvents
+} from "./chunk-QE46QFID.js";
+import {
+  defineTool,
+  toModelOutput
+} from "./chunk-PHTJLJOV.js";
+import {
+  defineSkill,
+  getSkill
+} from "./chunk-LQC65UHE.js";
+import {
+  defineInstructions,
+  loadInstructions
+} from "./chunk-L3BTL5FM.js";
+import {
+  defineHook
+} from "./chunk-3CNQ6HQV.js";
+import {
+  GET,
+  POST,
+  defineChannel
+} from "./chunk-ZJNHQXMO.js";
+import {
+  defineSchedule
+} from "./chunk-4L7WVCTU.js";
+import {
+  ensureContext,
+  getContext,
+  getSession,
+  getTurn,
+  hasContext,
+  requireContext,
+  setContext,
+  setSession,
+  setTurn
+} from "./chunk-WAD7VLNI.js";
+
+// src/connections/index.ts
+function defineConnection(config) {
+  if (!config.name || !config.description) {
+    throw new Error("Connection must have name and description");
+  }
+  if (!config.auth?.type) {
+    throw new Error("Connection must have an auth type");
+  }
+  return config;
+}
+export {
+  CencoriMemoryStore,
+  DEFAULT_TEMPLATE,
+  FileStore,
+  GET,
+  InMemoryStore,
+  KeyFactsStrategy,
+  LastNStrategy,
+  Memory,
+  POST,
+  SemanticRecall,
+  SqliteStore,
+  SummaryStrategy,
+  WORKING_MEMORY_SYSTEM_INSTRUCTION,
+  WorkingMemory,
+  basic,
+  bearer,
+  createMessageAppended,
+  createMessageCompleted,
+  createMessageReceived,
+  createReasoningAppended,
+  createReasoningCompleted,
+  createSessionCompleted,
+  createSessionFailed,
+  createSessionStarted,
+  createSessionWaiting,
+  createStepCompleted,
+  createStepFailed,
+  createStepStarted,
+  createSubagentCalled,
+  createSubagentCompleted,
+  createToolCallCompleted,
+  createToolCallStarted,
+  createTurnCompleted,
+  createTurnFailed,
+  createTurnStarted,
+  defineAgent,
+  defineChannel,
+  defineConnection,
+  defineHook,
+  defineInstructions,
+  defineSchedule,
+  defineSkill,
+  defineTool,
+  discoverAgent,
+  encodeEvent,
+  encodeEvents,
+  ensureContext,
+  getContext,
+  getSession,
+  getSkill,
+  getTurn,
+  hasContext,
+  loadAgent,
+  loadInstructions,
+  requireContext,
+  runAgent,
+  setContext,
+  setSession,
+  setTurn,
+  streamAgent,
+  toModelOutput
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC5H,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAIhD,OAAO,EACL,oBAAoB,EAAE,iBAAiB,EAAE,qBAAqB,EAC9D,qBAAqB,EAAE,sBAAsB,EAAE,iBAAiB,EAChE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAC9D,sBAAsB,EAAE,WAAW,EAAE,YAAY,GAClD,MAAM,sBAAsB,CAAC"}
+{"version":3,"sources":["../src/connections/index.ts"],"sourcesContent":["import type { ConnectionConfig } from \"../types\";\n\nexport function defineConnection(config: ConnectionConfig): ConnectionConfig {\n  if (!config.name || !config.description) {\n    throw new Error(\"Connection must have name and description\");\n  }\n  if (!config.auth?.type) {\n    throw new Error(\"Connection must have an auth type\");\n  }\n  return config;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEO,SAAS,iBAAiB,QAA4C;AAC3E,MAAI,CAAC,OAAO,QAAQ,CAAC,OAAO,aAAa;AACvC,UAAM,IAAI,MAAM,2CAA2C;AAAA,EAC7D;AACA,MAAI,CAAC,OAAO,MAAM,MAAM;AACtB,UAAM,IAAI,MAAM,mCAAmC;AAAA,EACrD;AACA,SAAO;AACT;","names":[]}