arcie 0.1.2 → 0.1.4

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 { d as ConnectionConfig, c as ToolConfig, e as SessionConfig, f as AgentManifest } from './types-BxOQTzx1.js';
+export { A as AgentConfig, g as ApprovalStrategy, h as CencoriConfig, C as ChannelConfig, i as ChannelRequest, j as ChannelResponse, H as HookConfig, k as HookEvent, l as HookPayload, I as InstructionsConfig, P as PolicyConfig, a as ScheduleConfig, S as Session, b as SkillConfig, m as SubagentManifest, n as ToolCallContext, T as TurnContext } from './types-BxOQTzx1.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-b4NcDl3m.js';
+export { e as MemoryQuery, r as runAgent, s as streamAgent } from './index-b4NcDl3m.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,159 @@
-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,
+  loadAgent,
+  runAgent,
+  streamAgent
+} from "./chunk-2ZSKZYWK.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":[]}

package/dist/instructions/index.d.ts

@@ -1,4 +1,7 @@
-import type { InstructionsConfig } from "../types.js";
-export declare function defineInstructions(source: string | InstructionsConfig): InstructionsConfig;
-export declare function loadInstructions(agentDir: string): InstructionsConfig | null;
-//# sourceMappingURL=index.d.ts.map
+import { I as InstructionsConfig } from '../types-BxOQTzx1.js';
+import 'zod';
+
+declare function defineInstructions(source: string | InstructionsConfig): InstructionsConfig;
+declare function loadInstructions(agentDir: string): InstructionsConfig | null;
+
+export { defineInstructions, loadInstructions };

package/dist/instructions/index.js

@@ -1,33 +1,9 @@
-import { readFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
-export function defineInstructions(source) {
-    if (typeof source === "string") {
-        const filePath = resolve(process.cwd(), source);
-        if (!existsSync(filePath)) {
-            throw new Error(`Instructions file not found: ${filePath}`);
-        }
-        return {
-            content: readFileSync(filePath, "utf-8"),
-            filePath,
-        };
-    }
-    return source;
-}
-export function loadInstructions(agentDir) {
-    const mdPath = resolve(agentDir, "instructions.md");
-    const tsPath = resolve(agentDir, "instructions.ts");
-    if (existsSync(mdPath)) {
-        return {
-            content: readFileSync(mdPath, "utf-8"),
-            filePath: mdPath,
-        };
-    }
-    if (existsSync(tsPath)) {
-        return {
-            content: readFileSync(tsPath, "utf-8"),
-            filePath: tsPath,
-        };
-    }
-    return null;
-}
+import {
+  defineInstructions,
+  loadInstructions
+} from "../chunk-L3BTL5FM.js";
+export {
+  defineInstructions,
+  loadInstructions
+};
 //# sourceMappingURL=index.js.map

package/dist/instructions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/instructions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,MAAM,UAAU,kBAAkB,CAChC,MAAmC;IAEnC,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;QAChD,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,gCAAgC,QAAQ,EAAE,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO;YACL,OAAO,EAAE,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC;YACxC,QAAQ;SACT,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,QAAgB;IAEhB,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC;IAEpD,IAAI,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC;YACtC,QAAQ,EAAE,MAAM;SACjB,CAAC;IACJ,CAAC;IACD,IAAI,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC;YACtC,QAAQ,EAAE,MAAM;SACjB,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}