@agent-creator/core 0.4.2

package/README.md

@@ -0,0 +1,24 @@
+# @agent-creator/core
+
+Composable Agent runtime for skills, memory, planning, execution, guards, traces, and OpenAI-compatible models.
+
+```ts
+import { createAgent } from '@agent-creator/core';
+
+const agent = createAgent({
+  model: {
+    baseUrl: 'https://api.openai.com/v1',
+    apiKey: process.env.OPENAI_API_KEY!,
+    model: 'gpt-4o-mini',
+  },
+})
+  .useSkill(mySkill)
+  .useMemory(myMemory)
+  .usePlanner(myPlanner)
+  .useExecutor(myExecutor)
+  .build();
+
+await agent.run({ input: 'Run my task', sessionId: 'session-1' });
+```
+
+`baseUrl`, `apiKey`, and `model` are required. The package does not read environment variables automatically.

package/dist/defaults.d.ts

@@ -0,0 +1,21 @@
+import type { AgentContext, AgentOutput, AgentPlan, Executor, ExecutorContext, Guard, MemoryMessage, MemoryProvider, Planner, TraceProvider, TraceRun } from './types.js';
+export declare class InMemoryProvider implements MemoryProvider {
+    private readonly sessions;
+    append(sessionId: string, message: MemoryMessage): void;
+    get(sessionId: string): MemoryMessage[];
+    clear(sessionId?: string): void;
+}
+export declare class DefaultGuard implements Guard {
+    check(): {
+        allowed: true;
+    };
+}
+export declare class DefaultPlanner implements Planner {
+    plan(context: AgentContext): AgentPlan;
+}
+export declare class DefaultExecutor implements Executor {
+    execute(plan: AgentPlan, context: ExecutorContext): Promise<AgentOutput>;
+}
+export declare class NoopTraceProvider implements TraceProvider {
+    start(): TraceRun;
+}

package/dist/defaults.js

@@ -0,0 +1,101 @@
+export class InMemoryProvider {
+    sessions = new Map();
+    append(sessionId, message) {
+        const messages = this.sessions.get(sessionId) ?? [];
+        messages.push(message);
+        this.sessions.set(sessionId, messages);
+    }
+    get(sessionId) {
+        return [...(this.sessions.get(sessionId) ?? [])];
+    }
+    clear(sessionId) {
+        if (sessionId)
+            this.sessions.delete(sessionId);
+        else
+            this.sessions.clear();
+    }
+}
+export class DefaultGuard {
+    check() {
+        return { allowed: true };
+    }
+}
+export class DefaultPlanner {
+    plan(context) {
+        const requestedSkill = findRequestedSkill(context);
+        if (requestedSkill) {
+            return {
+                goal: `Execute ${requestedSkill}`,
+                steps: [{ type: 'skill', skill: requestedSkill, input: context.input.metadata?.skillInput ?? context.input.input }],
+            };
+        }
+        return {
+            goal: 'Generate a response',
+            steps: [{ type: 'model', task: 'generate_response', input: context.input.input }],
+        };
+    }
+}
+export class DefaultExecutor {
+    async execute(plan, context) {
+        let lastOutput;
+        for (const step of plan.steps) {
+            if (step.type === 'response') {
+                lastOutput = { success: true, intent: 'response', message: step.message, data: step.data, traceId: context.traceId };
+            }
+            else if (step.type === 'skill') {
+                await context.trace.append({ type: 'skill.start', data: { name: step.skill } });
+                await context.emitProgress({ type: 'skill.started', message: `开始执行 ${step.skill}`, data: { skill: step.skill } });
+                const data = await context.skills.execute(step.skill, step.input, {
+                    traceId: context.traceId,
+                    sessionId: context.input.sessionId,
+                    userId: context.input.userId,
+                    metadata: context.input.metadata,
+                    emitProgress: context.emitProgress,
+                });
+                await context.emitProgress({ type: 'skill.completed', message: `执行 ${step.skill} 完成.`, data: { skill: step.skill } });
+                lastOutput = {
+                    success: true,
+                    intent: 'skill',
+                    message: `${step.skill} 调用成功.`,
+                    data,
+                    traceId: context.traceId,
+                };
+            }
+            else {
+                const memory = context.input.sessionId ? await context.memory.get(context.input.sessionId) : [];
+                await context.emitProgress({ type: 'model.started', message: '调用大模型分析', data: { task: step.task } });
+                const result = await context.model.generate({ task: step.task, input: step.input, memory });
+                await context.emitProgress({ type: 'model.completed', message: '大模型分析完成', data: { task: step.task } });
+                lastOutput = {
+                    success: true,
+                    intent: step.task,
+                    message: result.text,
+                    data: result.data,
+                    traceId: context.traceId,
+                };
+            }
+        }
+        return lastOutput ?? {
+            success: false,
+            intent: 'empty_plan',
+            message: '没有可执行的步骤',
+            traceId: context.traceId,
+        };
+    }
+}
+export class NoopTraceProvider {
+    start() {
+        return {
+            append() { },
+            end() { },
+        };
+    }
+}
+function findRequestedSkill(context) {
+    const explicit = context.input.metadata?.skill;
+    if (typeof explicit === 'string' && context.availableSkills.some((skill) => skill.name === explicit))
+        return explicit;
+    if (context.availableSkills.length === 1)
+        return context.availableSkills[0]?.name;
+    return context.availableSkills.find((skill) => context.input.input.startsWith(`${skill.name}:`))?.name;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { AgentBuilder, createAgent } from './runtime.js';
+export { DefaultExecutor, DefaultGuard, DefaultPlanner, InMemoryProvider, NoopTraceProvider } from './defaults.js';
+export { createOpenAICompatibleProvider, normalizeModelConfig } from './openAICompatibleProvider.js';
+export { SkillRegistry, ToolRegistry, toolToSkill } from './skillRegistry.js';
+export type { Agent, AgentContext, AgentInput, AgentOutput, AgentPlan, AgentPlanStep, AgentProgressEvent, AgentProgressHandler, CreateAgentOptions, Executor, ExecutorContext, Guard, GuardResult, MemoryMessage, MemoryProvider, ModelGenerateInput, ModelGenerateOutput, ModelProvider, OpenAICompatibleModelConfig, Planner, Skill, SkillContext, SkillRegistryLike, ToolDefinition, ToolRegistryLike, TraceEvent, TraceProvider, TraceRun, } from './types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { AgentBuilder, createAgent } from './runtime.js';
+export { DefaultExecutor, DefaultGuard, DefaultPlanner, InMemoryProvider, NoopTraceProvider } from './defaults.js';
+export { createOpenAICompatibleProvider, normalizeModelConfig } from './openAICompatibleProvider.js';
+export { SkillRegistry, ToolRegistry, toolToSkill } from './skillRegistry.js';

package/dist/openAICompatibleProvider.d.ts

@@ -0,0 +1,9 @@
+import type { ModelProvider, OpenAICompatibleModelConfig } from './types.js';
+export declare const DEFAULT_MODEL = "gpt-4o-mini";
+export interface OpenAICompatibleProviderOptions {
+    fetch?: typeof globalThis.fetch;
+}
+export declare function normalizeModelConfig(config: OpenAICompatibleModelConfig): Required<Omit<OpenAICompatibleModelConfig, 'headers'>> & {
+    headers: Record<string, string>;
+};
+export declare function createOpenAICompatibleProvider(modelConfig: OpenAICompatibleModelConfig, options?: OpenAICompatibleProviderOptions): ModelProvider;

package/dist/openAICompatibleProvider.js

@@ -0,0 +1,74 @@
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_RETRIES = 1;
+export const DEFAULT_MODEL = 'gpt-4o-mini';
+export function normalizeModelConfig(config) {
+    const baseUrl = requireValue(config.baseUrl, 'model.baseUrl').replace(/\/+$/, '');
+    const apiKey = requireValue(config.apiKey, 'model.apiKey');
+    const model = config.model?.trim() || DEFAULT_MODEL;
+    return {
+        baseUrl,
+        apiKey,
+        model,
+        timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+        headers: { ...(config.headers ?? {}) },
+    };
+}
+export function createOpenAICompatibleProvider(modelConfig, options = {}) {
+    const config = normalizeModelConfig(modelConfig);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl)
+        throw new Error('Global fetch is unavailable. Node.js 18 or newer is required.');
+    return {
+        async generate(input) {
+            let lastError;
+            for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), config.timeoutMs);
+                try {
+                    const response = await fetchImpl(`${config.baseUrl}/chat/completions`, {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json',
+                            authorization: `Bearer ${config.apiKey}`,
+                            ...config.headers,
+                        },
+                        body: JSON.stringify({
+                            model: config.model,
+                            messages: [
+                                ...input.memory.map((message) => ({ role: message.role, content: message.content })),
+                                { role: 'user', content: stringifyInput(input.input) },
+                            ],
+                        }),
+                        signal: controller.signal,
+                    });
+                    if (!response.ok)
+                        throw new Error(`model_request_failed: ${response.status} ${await response.text()}`);
+                    const payload = await response.json();
+                    const text = payload.choices?.[0]?.message?.content;
+                    if (!text)
+                        throw new Error('model_response_invalid: choices[0].message.content is missing');
+                    return { text };
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt === config.maxRetries)
+                        break;
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
+            throw lastError instanceof Error ? lastError : new Error(String(lastError));
+        },
+    };
+}
+function requireValue(value, field) {
+    const normalized = value?.trim();
+    if (!normalized)
+        throw new Error(`${field} is required.`);
+    return normalized;
+}
+function stringifyInput(input) {
+    return typeof input === 'string' ? input : JSON.stringify(input);
+}

package/dist/runtime.d.ts

@@ -0,0 +1,20 @@
+import type { Agent, CreateAgentOptions, Executor, Guard, MemoryProvider, ModelProvider, Planner, Skill, TraceProvider } from './types.js';
+export declare class AgentBuilder {
+    private readonly skills;
+    private memory;
+    private planner;
+    private executor;
+    private model;
+    private guard;
+    private trace;
+    constructor(options: CreateAgentOptions);
+    useSkill(skill: Skill): this;
+    useMemory(memory: MemoryProvider): this;
+    usePlanner(planner: Planner): this;
+    useExecutor(executor: Executor): this;
+    useModel(model: ModelProvider): this;
+    useGuard(guard: Guard): this;
+    useTrace(trace: TraceProvider): this;
+    build(): Agent;
+}
+export declare function createAgent(options: CreateAgentOptions): AgentBuilder;

package/dist/runtime.js

@@ -0,0 +1,164 @@
+import { DefaultExecutor, DefaultGuard, DefaultPlanner, InMemoryProvider, NoopTraceProvider } from './defaults.js';
+import { createOpenAICompatibleProvider, normalizeModelConfig } from './openAICompatibleProvider.js';
+import { SkillRegistry, toolToSkill } from './skillRegistry.js';
+export class AgentBuilder {
+    skills = new SkillRegistry();
+    memory = new InMemoryProvider();
+    planner = new DefaultPlanner();
+    executor = new DefaultExecutor();
+    model;
+    guard = new DefaultGuard();
+    trace = new NoopTraceProvider();
+    constructor(options) {
+        const modelConfig = normalizeModelConfig(options.model);
+        this.model = createOpenAICompatibleProvider(modelConfig);
+        for (const tool of options.tools ?? [])
+            this.skills.register(toolToSkill(tool));
+        for (const tool of options.toolRegistry?.listTools() ?? []) {
+            this.skills.register('execute' in tool ? tool : toolToSkill(tool));
+        }
+    }
+    useSkill(skill) {
+        this.skills.register(skill);
+        return this;
+    }
+    useMemory(memory) {
+        this.memory = memory;
+        return this;
+    }
+    usePlanner(planner) {
+        this.planner = planner;
+        return this;
+    }
+    useExecutor(executor) {
+        this.executor = executor;
+        return this;
+    }
+    useModel(model) {
+        this.model = model;
+        return this;
+    }
+    useGuard(guard) {
+        this.guard = guard;
+        return this;
+    }
+    useTrace(trace) {
+        this.trace = trace;
+        return this;
+    }
+    build() {
+        assertFunction(this.memory, 'get', 'memory');
+        assertFunction(this.memory, 'append', 'memory');
+        assertFunction(this.planner, 'plan', 'planner');
+        assertFunction(this.executor, 'execute', 'executor');
+        assertFunction(this.model, 'generate', 'model');
+        assertFunction(this.guard, 'check', 'guard');
+        assertFunction(this.trace, 'start', 'trace');
+        const runtime = {
+            skills: this.skills,
+            memory: this.memory,
+            planner: this.planner,
+            executor: this.executor,
+            model: this.model,
+            guard: this.guard,
+            trace: this.trace,
+        };
+        return {
+            async run(input) {
+                if (!input.input?.trim())
+                    throw new Error('input is required.');
+                const traceId = createId('trace');
+                const traceRun = runtime.trace.start(input, traceId);
+                const progress = progressEmitter(input, traceId);
+                try {
+                    await progress({ type: 'agent.started', message: '智能体开始工作', data: { input: input.input } });
+                    const memory = input.sessionId ? await runtime.memory.get(input.sessionId) : [];
+                    const context = {
+                        input,
+                        memory,
+                        availableSkills: runtime.skills.list().map(({ name, description }) => ({ name, description })),
+                    };
+                    await progress({ type: 'guard.started', message: '检查请求防护' });
+                    const guardResult = await runtime.guard.check(context);
+                    if (!guardResult.allowed) {
+                        const output = {
+                            success: false,
+                            intent: 'safe_redirect',
+                            message: guardResult.reason ?? 'The request was blocked by the guard.',
+                            traceId,
+                        };
+                        await progress({ type: 'guard.blocked', message: output.message });
+                        await traceRun.end(output);
+                        await progress({ type: 'agent.completed', message: 'Agent completed.', data: output });
+                        return output;
+                    }
+                    await progress({ type: 'guard.completed', message: '请求防护已通过' });
+                    if (input.sessionId) {
+                        await runtime.memory.append(input.sessionId, { role: 'user', content: input.input, at: new Date().toISOString() });
+                    }
+                    await progress({ type: 'planner.started', message: '正在规划后续步骤' });
+                    const plan = await runtime.planner.plan(context);
+                    await traceRun.append({ type: 'plan.created', data: plan });
+                    await progress({ type: 'plan.created', message: '计划已创建', data: plan });
+                    const output = await runtime.executor.execute(plan, {
+                        input,
+                        traceId,
+                        memory: runtime.memory,
+                        model: runtime.model,
+                        skills: runtime.skills,
+                        trace: traceRun,
+                        emitProgress: progress,
+                    });
+                    if (input.sessionId) {
+                        await runtime.memory.append(input.sessionId, {
+                            role: 'agent',
+                            content: output.message,
+                            data: output.data,
+                            at: new Date().toISOString(),
+                        });
+                    }
+                    await traceRun.end(output);
+                    await progress({ type: 'agent.completed', message: '智能体工作完成', data: output });
+                    return output;
+                }
+                catch (error) {
+                    const output = {
+                        success: false,
+                        intent: 'runtime_error',
+                        message: 'Agent execution failed.',
+                        errors: [error instanceof Error ? error.message : String(error)],
+                        traceId,
+                    };
+                    await traceRun.end(output);
+                    await progress({ type: 'agent.failed', message: 'Agent execution failed.', data: output });
+                    return output;
+                }
+            },
+        };
+    }
+}
+export function createAgent(options) {
+    if (!options?.model)
+        throw new Error('model configuration is required.');
+    return new AgentBuilder(options);
+}
+function assertFunction(value, key, moduleName) {
+    if (typeof value[key] !== 'function') {
+        throw new Error(`${moduleName}.${key} must be a function.`);
+    }
+}
+function createId(prefix) {
+    return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function progressEmitter(input, traceId) {
+    const handler = input.metadata?.onProgress;
+    return async (event) => {
+        if (typeof handler !== 'function')
+            return;
+        await handler({
+            ...event,
+            traceId,
+            at: new Date().toISOString(),
+        });
+    };
+}

package/dist/skillRegistry.d.ts

@@ -0,0 +1,20 @@
+import type { Skill, SkillContext, SkillRegistryLike, ToolDefinition } from './types.js';
+export declare class SkillRegistry implements SkillRegistryLike {
+    private readonly skills;
+    register(skill: Skill): void;
+    has(name: string): boolean;
+    get(name: string): Skill;
+    list(): Skill[];
+    execute(name: string, input: unknown, context: SkillContext): Promise<unknown>;
+}
+export declare function toolToSkill(tool: ToolDefinition): Skill;
+/** @deprecated Use SkillRegistry. */
+export declare class ToolRegistry {
+    private readonly registry;
+    registerTool(tool: ToolDefinition): void;
+    getTool(name: string): Skill;
+    listTools(): Skill[];
+    hasTool(name: string): boolean;
+    executeTool(name: string, input: unknown, context: SkillContext): Promise<unknown>;
+    toSkillRegistry(): SkillRegistry;
+}

package/dist/skillRegistry.js

@@ -0,0 +1,63 @@
+export class SkillRegistry {
+    skills = new Map();
+    register(skill) {
+        if (this.skills.has(skill.name)) {
+            throw new Error(`skill_already_registered: ${skill.name}`);
+        }
+        this.skills.set(skill.name, skill);
+    }
+    has(name) {
+        return this.skills.has(name);
+    }
+    get(name) {
+        const skill = this.skills.get(name);
+        if (!skill)
+            throw new Error(`skill_not_found: ${name}`);
+        return skill;
+    }
+    list() {
+        return [...this.skills.values()];
+    }
+    async execute(name, input, context) {
+        const skill = this.get(name);
+        const parsedInput = skill.inputSchema.safeParse(input);
+        if (!parsedInput.success)
+            throw new Error(`skill_input_invalid: ${parsedInput.error.message}`);
+        const output = await skill.execute(parsedInput.data, context);
+        const parsedOutput = skill.outputSchema.safeParse(output);
+        if (!parsedOutput.success)
+            throw new Error(`skill_output_invalid: ${parsedOutput.error.message}`);
+        return parsedOutput.data;
+    }
+}
+export function toolToSkill(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        execute: (input, context) => tool.handler(input, context),
+    };
+}
+/** @deprecated Use SkillRegistry. */
+export class ToolRegistry {
+    registry = new SkillRegistry();
+    registerTool(tool) {
+        this.registry.register(toolToSkill(tool));
+    }
+    getTool(name) {
+        return this.registry.get(name);
+    }
+    listTools() {
+        return this.registry.list();
+    }
+    hasTool(name) {
+        return this.registry.has(name);
+    }
+    executeTool(name, input, context) {
+        return this.registry.execute(name, input, context);
+    }
+    toSkillRegistry() {
+        return this.registry;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,157 @@
+import type { z } from 'zod';
+export interface OpenAICompatibleModelConfig {
+    baseUrl: string;
+    apiKey: string;
+    model?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    headers?: Record<string, string>;
+}
+export interface CreateAgentOptions {
+    model: OpenAICompatibleModelConfig;
+    /** @deprecated Register skills with builder.useSkill(). */
+    tools?: ToolDefinition[];
+    /** @deprecated Register skills with builder.useSkill(). */
+    toolRegistry?: ToolRegistryLike;
+}
+export interface AgentInput {
+    input: string;
+    userId?: string;
+    sessionId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentProgressEvent {
+    type: string;
+    message: string;
+    data?: unknown;
+    traceId: string;
+    at: string;
+}
+export type AgentProgressHandler = (event: AgentProgressEvent) => void | Promise<void>;
+export interface AgentOutput {
+    success: boolean;
+    intent: string;
+    message: string;
+    data?: unknown;
+    warnings?: string[];
+    errors?: string[];
+    traceId?: string;
+}
+export interface SkillContext {
+    traceId: string;
+    sessionId?: string;
+    userId?: string;
+    metadata?: Record<string, unknown>;
+    emitProgress?(event: Omit<AgentProgressEvent, 'traceId' | 'at'>): Promise<void>;
+}
+export interface Skill<I = unknown, O = unknown> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<I>;
+    outputSchema: z.ZodType<O>;
+    execute(input: I, context: SkillContext): Promise<O>;
+}
+export interface MemoryMessage {
+    role: 'user' | 'agent' | 'system';
+    content: string;
+    data?: unknown;
+    at: string;
+}
+export interface MemoryProvider {
+    append(sessionId: string, message: MemoryMessage): void | Promise<void>;
+    get(sessionId: string): MemoryMessage[] | Promise<MemoryMessage[]>;
+    clear(sessionId?: string): void | Promise<void>;
+}
+export interface ModelGenerateInput {
+    task: string;
+    input: unknown;
+    memory: MemoryMessage[];
+}
+export interface ModelGenerateOutput {
+    text: string;
+    data?: unknown;
+}
+export interface ModelProvider {
+    generate(input: ModelGenerateInput): Promise<ModelGenerateOutput>;
+}
+export interface AgentContext {
+    input: AgentInput;
+    memory: MemoryMessage[];
+    availableSkills: ReadonlyArray<Pick<Skill, 'name' | 'description'>>;
+}
+export interface AgentPlan {
+    goal: string;
+    steps: AgentPlanStep[];
+}
+export type AgentPlanStep = {
+    type: 'model';
+    task: string;
+    input: unknown;
+} | {
+    type: 'skill';
+    skill: string;
+    input: unknown;
+} | {
+    type: 'response';
+    message: string;
+    data?: unknown;
+};
+export interface Planner {
+    plan(context: AgentContext): AgentPlan | Promise<AgentPlan>;
+}
+export interface ExecutorContext {
+    input: AgentInput;
+    traceId: string;
+    memory: MemoryProvider;
+    model: ModelProvider;
+    skills: SkillRegistryLike;
+    trace: TraceRun;
+    emitProgress(event: Omit<AgentProgressEvent, 'traceId' | 'at'>): Promise<void>;
+}
+export interface Executor {
+    execute(plan: AgentPlan, context: ExecutorContext): Promise<AgentOutput>;
+}
+export interface GuardResult {
+    allowed: boolean;
+    reason?: string;
+}
+export interface Guard {
+    check(context: AgentContext): GuardResult | Promise<GuardResult>;
+}
+export interface TraceEvent {
+    type: string;
+    data?: unknown;
+    at: string;
+}
+export interface TraceRun {
+    append(event: Omit<TraceEvent, 'at'>): void | Promise<void>;
+    end(output: AgentOutput): void | Promise<void>;
+}
+export interface TraceProvider {
+    start(input: AgentInput, traceId: string): TraceRun;
+}
+export interface Agent {
+    run(input: AgentInput): Promise<AgentOutput>;
+}
+export interface SkillRegistryLike {
+    register(skill: Skill): void;
+    has(name: string): boolean;
+    get(name: string): Skill;
+    list(): Skill[];
+    execute(name: string, input: unknown, context: SkillContext): Promise<unknown>;
+}
+/** @deprecated Use Skill. */
+export interface ToolDefinition<I = unknown, O = unknown> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<I>;
+    outputSchema: z.ZodType<O>;
+    permission?: 'public' | 'external_api' | 'user_private';
+    timeoutMs?: number;
+    retry?: number;
+    handler(input: I, context: SkillContext): Promise<O>;
+}
+/** @deprecated Use SkillRegistry. */
+export interface ToolRegistryLike {
+    listTools(): Array<ToolDefinition | Skill>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@agent-creator/core",
+  "version": "0.4.2",
+  "description": "Composable Agent runtime with skills, memory, planning, execution, and OpenAI-compatible models.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "check:package": "npm pack --dry-run --json"
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.12",
+    "typescript": "^5.9.3",
+    "vitest": "^2.0.5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}