@looopy-ai/core 1.1.1 → 1.1.3

package/dist/core/agent.d.ts

@@ -6,6 +6,7 @@ import type { AnyEvent } from '../types/event';
 import type { LLMProvider } from '../types/llm';
 import type { Message } from '../types/message';
 import type { ToolProvider } from '../types/tools';
+import type { SystemPromptProp } from '../utils/prompt';
 export interface AgentConfig {
     agentId: string;
     contextId: string;
@@ -15,7 +16,7 @@ export interface AgentConfig {
     agentStore?: AgentStore;
     autoCompact?: boolean;
     maxMessages?: number;
-    systemPrompt?: string;
+    systemPrompt?: SystemPromptProp;
     logger?: import('pino').Logger;
 }
 export interface GetMessagesOptions {

package/dist/core/agent.js

@@ -14,7 +14,6 @@ export class Agent {
         this.config = {
             autoCompact: false,
             maxMessages: 100,
-            systemPrompt: 'You are a helpful AI assistant.',
             ...config,
             logger: config.logger?.child({ contextId: config.contextId }) ||
                 getLogger({ contextId: config.contextId }),

package/dist/core/iteration.js

@@ -1,5 +1,6 @@
 import { concat, defer, filter, map, mergeMap, shareReplay } from 'rxjs';
 import { startLLMCallSpan, startLoopIterationSpan } from '../observability/spans';
+import { getSystemPrompt } from '../utils/prompt';
 import { runToolCall } from './tools';
 export const runIteration = (context, config, history) => {
     const logger = context.logger.child({
@@ -8,11 +9,12 @@ export const runIteration = (context, config, history) => {
     });
     const { traceContext: iterationContext, tapFinish: finishIterationSpan } = startLoopIterationSpan({ ...context, logger }, config.iterationNumber);
     const llmEvents$ = defer(async () => {
-        const messages = prepareMessages(context, history);
+        const systemPrompt = await getSystemPrompt(context.systemPrompt);
+        const messages = await prepareMessages(systemPrompt, context.skillPrompts, history);
         const tools = await prepareTools(context.toolProviders);
-        return { messages, tools };
-    }).pipe(mergeMap(({ messages, tools }) => {
-        const { tapFinish: finishLLMCallSpan } = startLLMCallSpan({ ...context, parentContext: iterationContext }, messages);
+        return { messages, tools, systemPrompt };
+    }).pipe(mergeMap(({ messages, tools, systemPrompt }) => {
+        const { tapFinish: finishLLMCallSpan } = startLLMCallSpan({ ...context, parentContext: iterationContext }, systemPrompt, messages);
         return config.llmProvider
             .call({
             messages,
@@ -33,17 +35,17 @@ export const runIteration = (context, config, history) => {
     }, event)));
     return concat(llmEvents$.pipe(filter((event) => event.kind !== 'tool-call')), toolEvents$).pipe(finishIterationSpan);
 };
-const prepareMessages = (context, history) => {
+const prepareMessages = async (systemPrompt, skillPrompts, history) => {
     const messages = [];
-    if (context.systemPrompt) {
+    if (systemPrompt) {
         messages.push({
             role: 'system',
-            content: context.systemPrompt,
-            name: 'system-prompt',
+            content: systemPrompt.prompt,
+            name: systemPrompt.name || 'system-prompt',
         });
     }
-    if (context.skillPrompts) {
-        for (const [name, content] of Object.entries(context.skillPrompts)) {
+    if (skillPrompts) {
+        for (const [name, content] of Object.entries(skillPrompts)) {
             messages.push({
                 role: 'system',
                 content,

package/dist/core/loop.d.ts

@@ -1,5 +1,4 @@
-import { type Observable } from 'rxjs';
 import type { AnyEvent } from '../types/event';
 import type { Message } from '../types/message';
 import type { LoopConfig, TurnContext } from './types';
-export declare const runLoop: (context: TurnContext, config: LoopConfig, history: Message[]) => Observable<AnyEvent>;
+export declare const runLoop: (context: TurnContext, config: LoopConfig, history: Message[]) => import("rxjs").Observable<AnyEvent>;

package/dist/core/loop.js

@@ -1,6 +1,7 @@
-import { concat, EMPTY, expand, map, mergeMap, of, reduce, share, shareReplay, } from 'rxjs';
+import { concat, EMPTY, mergeMap, of, reduce, shareReplay } from 'rxjs';
 import { createTaskCompleteEvent, createTaskCreatedEvent, createTaskStatusEvent } from '../events';
 import { startAgentLoopSpan } from '../observability/spans';
+import { recursiveMerge } from '../utils/recursive-merge';
 import { runIteration } from './iteration';
 export const runLoop = (context, config, history) => {
     const logger = context.logger.child({ component: 'loop' });
@@ -49,34 +50,6 @@ export const runLoop = (context, config, history) => {
     }));
     return concat(of(taskEvent, workingEvent), merged$, finalSummary$).pipe(tapFinish);
 };
-function recursiveMerge(initial, eventsFor, next, isStop) {
-    const seed = {
-        state: initial,
-        iteration: 0,
-        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay()),
-    };
-    const iterations$ = of(seed).pipe(expand(({ state, iteration, events$ }) => events$.pipe(reduce((acc, e) => {
-        acc.events.push(e);
-        if (isStop(e))
-            acc.sawStop = true;
-        return acc;
-    }, { events: [], sawStop: false }), mergeMap(({ events, sawStop }) => {
-        if (sawStop)
-            return EMPTY;
-        return of(next(state, { iteration, events })).pipe(map((nextState) => {
-            const nextIter = iteration + 1;
-            return {
-                state: nextState,
-                iteration: nextIter,
-                events$: eventsFor({
-                    ...nextState,
-                    iteration: nextIter,
-                }).pipe(share()),
-            };
-        }));
-    }))));
-    return iterations$.pipe(mergeMap(({ events$ }) => events$));
-}
 const eventsToMessages = (events) => {
     const messages = [];
     for (const event of events) {
@@ -88,22 +61,13 @@ const eventsToMessages = (events) => {
                         content: event.content,
                     });
                 }
-                break;
-            case 'tool-call':
-                messages.push({
-                    role: 'assistant',
-                    content: '',
-                    toolCalls: [
-                        {
-                            id: event.toolCallId,
-                            type: 'function',
-                            function: {
-                                name: event.toolName,
-                                arguments: event.arguments,
-                            },
-                        },
-                    ],
-                });
+                if (event.finishReason === 'tool_calls' && (event.toolCalls?.length ?? 0) > 0) {
+                    messages.push({
+                        role: 'assistant',
+                        content: '',
+                        toolCalls: event.toolCalls,
+                    });
+                }
                 break;
             case 'tool-complete':
                 messages.push({

package/dist/core/tools.js

@@ -17,7 +17,7 @@ export const runToolCall = (context, toolCall) => {
             return of(toolCall);
         }
         const { provider, tool } = matchingProvider;
-        logger.trace({ providerName: provider.name }, 'Found tool provider for tool');
+        logger.debug({ providerName: provider.name, toolIcon: tool.icon }, 'Found tool provider for tool');
         const toolStartEvent = {
             kind: 'tool-start',
             contextId: context.contextId,
@@ -43,7 +43,9 @@ export const runToolCall = (context, toolCall) => {
                 logger.trace({
                     success: result.success,
                 }, 'Tool execution complete');
-                return createToolCompleteEvent(context, toolCall, result.result);
+                return result.success
+                    ? createToolCompleteEvent(context, toolCall, result.result)
+                    : createToolErrorEvent(context, toolCall, result.error || 'Unknown error');
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));

package/dist/observability/spans/llm-call.d.ts

@@ -1,13 +1,14 @@
 import type { LoopContext } from '../../core/types';
 import type { AnyEvent } from '../../types/event';
 import type { Message } from '../../types/message';
+import type { SystemPrompt } from '../../utils/prompt';
 export interface LLMCallSpanParams {
     agentId: string;
     taskId: string;
     messages: Message[];
     parentContext: import('@opentelemetry/api').Context;
 }
-export declare const startLLMCallSpan: (context: LoopContext, messages: Message[]) => {
+export declare const startLLMCallSpan: (context: LoopContext, systemPrompt: SystemPrompt | undefined, messages: Message[]) => {
     span: import("@opentelemetry/api").Span;
     traceContext: import("@opentelemetry/api").Context;
     tapFinish: import("rxjs").MonoTypeOperatorFunction<AnyEvent>;

package/dist/observability/spans/llm-call.js

@@ -1,7 +1,7 @@
 import { SpanStatusCode, trace } from '@opentelemetry/api';
 import { tap } from 'rxjs/internal/operators/tap';
 import { SpanAttributes, SpanNames } from '../tracing';
-export const startLLMCallSpan = (context, messages) => {
+export const startLLMCallSpan = (context, systemPrompt, messages) => {
     const tracer = trace.getTracer('looopy');
     const span = tracer.startSpan(SpanNames.LLM_CALL, {
         attributes: {
@@ -9,6 +9,8 @@ export const startLLMCallSpan = (context, messages) => {
             [SpanAttributes.TASK_ID]: context.taskId,
             [SpanAttributes.GEN_AI_PROMPT]: JSON.stringify(messages),
             [SpanAttributes.LANGFUSE_OBSERVATION_TYPE]: 'generation',
+            [SpanAttributes.LANGFUSE_PROMPT_NAME]: systemPrompt?.name,
+            [SpanAttributes.LANGFUSE_PROMPT_VERSION]: systemPrompt?.version,
         },
     }, context.parentContext);
     const traceContext = trace.setSpan(context.parentContext, span);

package/dist/observability/tracing.d.ts

@@ -33,6 +33,8 @@ export declare const SpanAttributes: {
     readonly LANGFUSE_METADATA: "langfuse.metadata";
     readonly LANGFUSE_VERSION: "langfuse.version";
     readonly LANGFUSE_RELEASE: "langfuse.release";
+    readonly LANGFUSE_PROMPT_NAME: "langfuse.prompt.name";
+    readonly LANGFUSE_PROMPT_VERSION: "langfuse.prompt.version";
     readonly GEN_AI_SYSTEM: "gen_ai.system";
     readonly GEN_AI_REQUEST_MODEL: "gen_ai.request.model";
     readonly GEN_AI_RESPONSE_MODEL: "gen_ai.response.model";

package/dist/observability/tracing.js

@@ -178,6 +178,8 @@ export const SpanAttributes = {
     LANGFUSE_METADATA: 'langfuse.metadata',
     LANGFUSE_VERSION: 'langfuse.version',
     LANGFUSE_RELEASE: 'langfuse.release',
+    LANGFUSE_PROMPT_NAME: 'langfuse.prompt.name',
+    LANGFUSE_PROMPT_VERSION: 'langfuse.prompt.version',
     GEN_AI_SYSTEM: 'gen_ai.system',
     GEN_AI_REQUEST_MODEL: 'gen_ai.request.model',
     GEN_AI_RESPONSE_MODEL: 'gen_ai.response.model',

package/dist/providers/litellm-provider.js

@@ -107,14 +107,14 @@ export class LiteLLMProvider {
             ...usage,
             timestamp: new Date().toISOString(),
         })), this.debugLog('llm-usage'));
-        const toolCalls$ = contentComplete$.pipe(mergeMap((event) => event.toolCalls?.map((tc) => ({
+        const toolCalls$ = contentComplete$.pipe(filter((event) => event.finishReason === 'tool_calls'), mergeMap((event) => event.toolCalls?.map((tc) => ({
             kind: 'tool-call',
             toolCallId: tc.id,
             toolName: tc.function.name,
             arguments: tc.function.arguments,
             timestamp: event.timestamp,
         })) || []));
-        return merge(contentDeltas$, thoughts$, usageComplete$, toolCalls$).pipe(concatWith(contentComplete$));
+        return merge(contentDeltas$, thoughts$, usageComplete$).pipe(concatWith(toolCalls$), concatWith(contentComplete$));
     }
     debugLogRawChunk(chunk) {
         if (!this.config.debugLogPath) {

package/dist/tools/artifact-tools.js

@@ -13,265 +13,335 @@ async function trackArtifactInState(taskId, artifactId, taskStateStore) {
 export function createArtifactTools(artifactStore, taskStateStore) {
     const scheduledStore = new ArtifactScheduler(artifactStore);
     return localTools([
-        tool('create_file_artifact', 'Create a new file artifact for streaming text or binary content. Use append_file_chunk to add content. Set override=true to replace existing artifact.', z.object({
-            artifactId: z
-                .string()
-                .describe('Unique identifier for the artifact (e.g., "report-2025", "analysis-results")'),
-            name: z.string().optional().describe('Human-readable name for the artifact'),
-            description: z.string().optional().describe('Description of the artifact content'),
-            mimeType: z
-                .string()
-                .optional()
-                .default('text/plain')
-                .describe('MIME type of the content (e.g., "text/plain", "text/markdown")'),
-            encoding: z
-                .enum(['utf-8', 'base64'])
-                .optional()
-                .default('utf-8')
-                .describe('Content encoding'),
-            override: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Set to true to replace an existing artifact with the same ID'),
-        }), async (params, context) => {
-            await scheduledStore.createFileArtifact({
-                artifactId: params.artifactId,
-                taskId: context.taskId,
-                contextId: context.contextId,
-                name: params.name,
-                description: params.description,
-                mimeType: params.mimeType,
-                encoding: params.encoding,
-                override: params.override,
-            });
-            await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
-            return {
-                artifactId: params.artifactId,
-                type: 'file',
-                status: 'building',
-                message: params.override
-                    ? 'File artifact reset. Use append_file_chunk to add content.'
-                    : 'File artifact created. Use append_file_chunk to add content.',
-            };
+        tool({
+            name: 'create_file_artifact',
+            description: 'Create a new file artifact for streaming text or binary content. Use append_file_chunk to add content. Set override=true to replace existing artifact.',
+            schema: z.object({
+                artifactId: z
+                    .string()
+                    .describe('Unique identifier for the artifact (e.g., "report-2025", "analysis-results")'),
+                name: z.string().optional().describe('Human-readable name for the artifact'),
+                description: z.string().optional().describe('Description of the artifact content'),
+                mimeType: z
+                    .string()
+                    .optional()
+                    .default('text/plain')
+                    .describe('MIME type of the content (e.g., "text/plain", "text/markdown")'),
+                encoding: z
+                    .enum(['utf-8', 'base64'])
+                    .optional()
+                    .default('utf-8')
+                    .describe('Content encoding'),
+                override: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe('Set to true to replace an existing artifact with the same ID'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.createFileArtifact({
+                    artifactId: params.artifactId,
+                    taskId: context.taskId,
+                    contextId: context.contextId,
+                    name: params.name,
+                    description: params.description,
+                    mimeType: params.mimeType,
+                    encoding: params.encoding,
+                    override: params.override,
+                });
+                await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
+                return {
+                    artifactId: params.artifactId,
+                    type: 'file',
+                    status: 'building',
+                    message: params.override
+                        ? 'File artifact reset. Use append_file_chunk to add content.'
+                        : 'File artifact created. Use append_file_chunk to add content.',
+                };
+            },
         }),
-        tool('append_file_chunk', 'Append a chunk of content to a file artifact. Call multiple times to stream content.', z.object({
-            artifactId: z.string().describe('The artifact ID to append to'),
-            content_chunk: z.string().describe('Content chunk to append to the file'),
-            isLastChunk: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Set to true on the final chunk to mark artifact as complete'),
-        }), async (params, context) => {
-            await scheduledStore.appendFileChunk(context.contextId, params.artifactId, params.content_chunk, {
-                isLastChunk: params.isLastChunk,
-            });
-            return {
-                artifactId: params.artifactId,
-                chunkAdded: true,
-                complete: params.isLastChunk,
-                message: params.isLastChunk
-                    ? 'Final chunk appended. Artifact is complete.'
-                    : 'Chunk appended successfully.',
-            };
+        tool({
+            name: 'append_file_chunk',
+            description: 'Append a chunk of content to a file artifact. Call multiple times to stream content.',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to append to'),
+                content_chunk: z.string().describe('Content chunk to append to the file'),
+                isLastChunk: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe('Set to true on the final chunk to mark artifact as complete'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.appendFileChunk(context.contextId, params.artifactId, params.content_chunk, {
+                    isLastChunk: params.isLastChunk,
+                });
+                return {
+                    artifactId: params.artifactId,
+                    chunkAdded: true,
+                    complete: params.isLastChunk,
+                    message: params.isLastChunk
+                        ? 'Final chunk appended. Artifact is complete.'
+                        : 'Chunk appended successfully.',
+                };
+            },
         }),
-        tool('get_file_content', 'Get the complete content of a file artifact', z.object({
-            artifactId: z.string().describe('The artifact ID to retrieve'),
-        }), async (params, context) => {
-            const content = await scheduledStore.getFileContent(context.contextId, params.artifactId);
-            return {
-                artifactId: params.artifactId,
-                content,
-            };
+        tool({
+            name: 'get_file_content',
+            description: 'Get the complete content of a file artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to retrieve'),
+            }),
+            handler: async (params, context) => {
+                const content = await scheduledStore.getFileContent(context.contextId, params.artifactId);
+                return {
+                    artifactId: params.artifactId,
+                    content,
+                };
+            },
         }),
-        tool('create_data_artifact', 'Create a data artifact with structured JSON data. Set override=true to replace existing artifact.', z.object({
-            artifactId: z.string().describe('Unique identifier for the artifact'),
-            name: z.string().optional().describe('Human-readable name'),
-            description: z.string().optional().describe('Description of the data'),
-            data: z.record(z.string(), z.unknown()).describe('The structured data object'),
-            override: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Set to true to replace an existing artifact with the same ID'),
-        }), async (params, context) => {
-            await scheduledStore.createDataArtifact({
-                artifactId: params.artifactId,
-                taskId: context.taskId,
-                contextId: context.contextId,
-                name: params.name,
-                description: params.description,
-                override: params.override,
-            });
-            await scheduledStore.writeData(context.contextId, params.artifactId, params.data);
-            await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
-            return {
-                artifactId: params.artifactId,
-                type: 'data',
-                status: 'complete',
-                message: params.override
-                    ? 'Data artifact reset successfully.'
-                    : 'Data artifact created successfully.',
-            };
+        tool({
+            name: 'create_data_artifact',
+            description: 'Create a data artifact with structured JSON data. Set override=true to replace existing artifact.',
+            schema: z.object({
+                artifactId: z.string().describe('Unique identifier for the artifact'),
+                name: z.string().optional().describe('Human-readable name'),
+                description: z.string().optional().describe('Description of the data'),
+                data: z.record(z.string(), z.unknown()).describe('The structured data object'),
+                override: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe('Set to true to replace an existing artifact with the same ID'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.createDataArtifact({
+                    artifactId: params.artifactId,
+                    taskId: context.taskId,
+                    contextId: context.contextId,
+                    name: params.name,
+                    description: params.description,
+                    override: params.override,
+                });
+                await scheduledStore.writeData(context.contextId, params.artifactId, params.data);
+                await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
+                return {
+                    artifactId: params.artifactId,
+                    type: 'data',
+                    status: 'complete',
+                    message: params.override
+                        ? 'Data artifact reset successfully.'
+                        : 'Data artifact created successfully.',
+                };
+            },
         }),
-        tool('update_data_artifact', 'Update the data content of an existing data artifact', z.object({
-            artifactId: z.string().describe('The artifact ID to update'),
-            data: z.record(z.string(), z.unknown()).describe('The new data object'),
-        }), async (params, context) => {
-            await scheduledStore.writeData(context.contextId, params.artifactId, params.data);
-            return {
-                artifactId: params.artifactId,
-                type: 'data',
-                status: 'complete',
-                message: 'Data artifact updated successfully.',
-            };
+        tool({
+            name: 'update_data_artifact',
+            description: 'Update the data content of an existing data artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to update'),
+                data: z.record(z.string(), z.unknown()).describe('The new data object'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.writeData(context.contextId, params.artifactId, params.data);
+                return {
+                    artifactId: params.artifactId,
+                    type: 'data',
+                    status: 'complete',
+                    message: 'Data artifact updated successfully.',
+                };
+            },
         }),
-        tool('get_data_content', 'Get the content of a data artifact', z.object({
-            artifactId: z.string().describe('The artifact ID to retrieve'),
-        }), async (params, context) => {
-            const data = await scheduledStore.getDataContent(context.contextId, params.artifactId);
-            return {
-                artifactId: params.artifactId,
-                data,
-            };
+        tool({
+            name: 'get_data_content',
+            description: 'Get the content of a data artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to retrieve'),
+            }),
+            handler: async (params, context) => {
+                const data = await scheduledStore.getDataContent(context.contextId, params.artifactId);
+                return {
+                    artifactId: params.artifactId,
+                    data,
+                };
+            },
         }),
-        tool('get_data_artifact', 'Get the data content of a data artifact', z.object({
-            artifactId: z.string().describe('The artifact ID to retrieve'),
-        }), async (params, context) => {
-            const data = await scheduledStore.getDataContent(context.contextId, params.artifactId);
-            return {
-                artifactId: params.artifactId,
-                data,
-            };
+        tool({
+            name: 'get_data_artifact',
+            description: 'Get the data content of a data artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to retrieve'),
+            }),
+            handler: async (params, context) => {
+                const data = await scheduledStore.getDataContent(context.contextId, params.artifactId);
+                return {
+                    artifactId: params.artifactId,
+                    data,
+                };
+            },
         }),
-        tool('create_dataset_artifact', 'Create a dataset artifact for tabular data with a schema. Set override=true to replace existing artifact.', z.object({
-            artifactId: z.string().describe('Unique identifier for the dataset'),
-            name: z.string().optional().describe('Human-readable name'),
-            description: z.string().optional().describe('Description of the dataset'),
+        tool({
+            name: 'create_dataset_artifact',
+            description: 'Create a dataset artifact for tabular data with a schema. Set override=true to replace existing artifact.',
             schema: z.object({
-                columns: z.array(z.object({
-                    name: z.string(),
-                    type: z.enum(['string', 'number', 'boolean', 'date', 'json']),
-                    description: z.string().optional(),
-                })),
+                artifactId: z.string().describe('Unique identifier for the dataset'),
+                name: z.string().optional().describe('Human-readable name'),
+                description: z.string().optional().describe('Description of the dataset'),
+                schema: z.object({
+                    columns: z.array(z.object({
+                        name: z.string(),
+                        type: z.enum(['string', 'number', 'boolean', 'date', 'json']),
+                        description: z.string().optional(),
+                    })),
+                }),
+                override: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe('Set to true to replace an existing artifact with the same ID'),
             }),
-            override: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Set to true to replace an existing artifact with the same ID'),
-        }), async (params, context) => {
-            await scheduledStore.createDatasetArtifact({
-                artifactId: params.artifactId,
-                taskId: context.taskId,
-                contextId: context.contextId,
-                name: params.name,
-                description: params.description,
-                schema: params.schema,
-                override: params.override,
-            });
-            await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
-            return {
-                artifactId: params.artifactId,
-                type: 'dataset',
-                status: 'building',
-                message: params.override
-                    ? 'Dataset artifact reset. Use append_dataset_row(s) to add data.'
-                    : 'Dataset artifact created. Use append_dataset_row(s) to add data.',
-            };
+            handler: async (params, context) => {
+                await scheduledStore.createDatasetArtifact({
+                    artifactId: params.artifactId,
+                    taskId: context.taskId,
+                    contextId: context.contextId,
+                    name: params.name,
+                    description: params.description,
+                    schema: params.schema,
+                    override: params.override,
+                });
+                await trackArtifactInState(context.taskId, params.artifactId, taskStateStore);
+                return {
+                    artifactId: params.artifactId,
+                    type: 'dataset',
+                    status: 'building',
+                    message: params.override
+                        ? 'Dataset artifact reset. Use append_dataset_row(s) to add data.'
+                        : 'Dataset artifact created. Use append_dataset_row(s) to add data.',
+                };
+            },
         }),
-        tool('append_dataset_row', 'Append a single row to a dataset artifact', z.object({
-            artifactId: z.string().describe('The dataset artifact ID'),
-            row: z.record(z.string(), z.unknown()).describe('Row data matching the dataset schema'),
-        }), async (params, context) => {
-            await scheduledStore.appendDatasetBatch(context.contextId, params.artifactId, [params.row]);
-            return {
-                artifactId: params.artifactId,
-                rowAdded: true,
-                message: 'Row appended to dataset.',
-            };
+        tool({
+            name: 'append_dataset_row',
+            description: 'Append a single row to a dataset artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The dataset artifact ID'),
+                row: z.record(z.string(), z.unknown()).describe('Row data matching the dataset schema'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.appendDatasetBatch(context.contextId, params.artifactId, [params.row]);
+                return {
+                    artifactId: params.artifactId,
+                    rowAdded: true,
+                    message: 'Row appended to dataset.',
+                };
+            },
         }),
-        tool('append_dataset_rows', 'Append multiple rows to a dataset artifact', z.object({
-            artifactId: z.string().describe('The dataset artifact ID'),
-            rows: z.array(z.record(z.string(), z.unknown())).describe('Array of rows to append'),
-            isLastBatch: z.boolean().optional().describe('Set to true on the final batch'),
-        }), async (params, context) => {
-            await scheduledStore.appendDatasetBatch(context.contextId, params.artifactId, params.rows, {
-                isLastBatch: params.isLastBatch,
-            });
-            return {
-                artifactId: params.artifactId,
-                rowsAdded: params.rows.length,
-                message: `${params.rows.length} rows appended to dataset.`,
-            };
+        tool({
+            name: 'append_dataset_rows',
+            description: 'Append multiple rows to a dataset artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The dataset artifact ID'),
+                rows: z.array(z.record(z.string(), z.unknown())).describe('Array of rows to append'),
+                isLastBatch: z.boolean().optional().describe('Set to true on the final batch'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.appendDatasetBatch(context.contextId, params.artifactId, params.rows, {
+                    isLastBatch: params.isLastBatch,
+                });
+                return {
+                    artifactId: params.artifactId,
+                    rowsAdded: params.rows.length,
+                    message: `${params.rows.length} rows appended to dataset.`,
+                };
+            },
         }),
-        tool('get_dataset_rows', 'Get all rows from a dataset artifact', z.object({
-            artifactId: z.string().describe('The dataset artifact ID'),
-        }), async (params, context) => {
-            const rows = await scheduledStore.getDatasetRows(context.contextId, params.artifactId);
-            return {
-                artifactId: params.artifactId,
-                rows,
-                totalRows: rows.length,
-            };
+        tool({
+            name: 'get_dataset_rows',
+            description: 'Get all rows from a dataset artifact',
+            schema: z.object({
+                artifactId: z.string().describe('The dataset artifact ID'),
+            }),
+            handler: async (params, context) => {
+                const rows = await scheduledStore.getDatasetRows(context.contextId, params.artifactId);
+                return {
+                    artifactId: params.artifactId,
+                    rows,
+                    totalRows: rows.length,
+                };
+            },
         }),
-        tool('list_artifacts', 'List all artifacts in the current context, optionally filtered by task', z.object({
-            taskId: z.string().optional().describe('Filter artifacts by task ID'),
-        }), async (params, context) => {
-            const artifactIds = await scheduledStore.listArtifacts(context.contextId, params.taskId);
-            const artifacts = await Promise.all(artifactIds.map((id) => scheduledStore.getArtifact(context.contextId, id)));
-            const validArtifacts = artifacts.filter((a) => a !== null);
-            return {
-                artifacts: validArtifacts.map((a) => ({
-                    artifactId: a.artifactId,
-                    type: a.type,
-                    name: a.name,
-                    taskId: a.taskId,
-                    contextId: a.contextId,
-                    createdAt: a.createdAt,
-                })),
-                totalCount: validArtifacts.length,
-            };
+        tool({
+            name: 'list_artifacts',
+            description: 'List all artifacts in the current context, optionally filtered by task',
+            schema: z.object({
+                taskId: z.string().optional().describe('Filter artifacts by task ID'),
+            }),
+            handler: async (params, context) => {
+                const artifactIds = await scheduledStore.listArtifacts(context.contextId, params.taskId);
+                const artifacts = await Promise.all(artifactIds.map((id) => scheduledStore.getArtifact(context.contextId, id)));
+                const validArtifacts = artifacts.filter((a) => a !== null);
+                return {
+                    artifacts: validArtifacts.map((a) => ({
+                        artifactId: a.artifactId,
+                        type: a.type,
+                        name: a.name,
+                        taskId: a.taskId,
+                        contextId: a.contextId,
+                        createdAt: a.createdAt,
+                    })),
+                    totalCount: validArtifacts.length,
+                };
+            },
         }),
-        tool('get_artifact', 'Get metadata for a specific artifact by ID', z.object({
-            artifactId: z.string().describe('The artifact ID to retrieve'),
-        }), async (params, context) => {
-            const artifact = await scheduledStore.getArtifact(context.contextId, params.artifactId);
-            if (!artifact) {
-                throw new Error(`Artifact not found: ${params.artifactId}`);
-            }
-            return {
-                artifactId: artifact.artifactId,
-                type: artifact.type,
-                taskId: artifact.taskId,
-                contextId: artifact.contextId,
-                name: artifact.name,
-                description: artifact.description,
-                status: artifact.status,
-                createdAt: artifact.createdAt,
-                updatedAt: artifact.updatedAt,
-                ...(artifact.type === 'file' && {
-                    mimeType: artifact.mimeType,
-                    encoding: artifact.encoding,
-                    totalChunks: artifact.totalChunks,
-                    totalSize: artifact.totalSize,
-                }),
-                ...(artifact.type === 'dataset' && {
-                    totalRows: artifact.totalSize,
-                    schema: artifact.schema,
-                }),
-            };
+        tool({
+            name: 'get_artifact',
+            description: 'Get metadata for a specific artifact by ID',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to retrieve'),
+            }),
+            handler: async (params, context) => {
+                const artifact = await scheduledStore.getArtifact(context.contextId, params.artifactId);
+                if (!artifact) {
+                    throw new Error(`Artifact not found: ${params.artifactId}`);
+                }
+                return {
+                    artifactId: artifact.artifactId,
+                    type: artifact.type,
+                    taskId: artifact.taskId,
+                    contextId: artifact.contextId,
+                    name: artifact.name,
+                    description: artifact.description,
+                    status: artifact.status,
+                    createdAt: artifact.createdAt,
+                    updatedAt: artifact.updatedAt,
+                    ...(artifact.type === 'file' && {
+                        mimeType: artifact.mimeType,
+                        encoding: artifact.encoding,
+                        totalChunks: artifact.totalChunks,
+                        totalSize: artifact.totalSize,
+                    }),
+                    ...(artifact.type === 'dataset' && {
+                        totalRows: artifact.totalSize,
+                        schema: artifact.schema,
+                    }),
+                };
+            },
         }),
-        tool('delete_artifact', 'Delete an artifact by ID', z.object({
-            artifactId: z.string().describe('The artifact ID to delete'),
-        }), async (params, context) => {
-            await scheduledStore.deleteArtifact(context.contextId, params.artifactId);
-            return {
-                artifactId: params.artifactId,
-                deleted: true,
-                message: 'Artifact deleted successfully.',
-            };
+        tool({
+            name: 'delete_artifact',
+            description: 'Delete an artifact by ID',
+            schema: z.object({
+                artifactId: z.string().describe('The artifact ID to delete'),
+            }),
+            handler: async (params, context) => {
+                await scheduledStore.deleteArtifact(context.contextId, params.artifactId);
+                return {
+                    artifactId: params.artifactId,
+                    deleted: true,
+                    message: 'Artifact deleted successfully.',
+                };
+            },
         }),
     ]);
 }

package/dist/tools/local-tools.d.ts

@@ -9,5 +9,5 @@ export interface LocalToolDefinition<TSchema extends z.ZodObject> {
     schema: TSchema;
     handler: ToolHandler<z.infer<TSchema>>;
 }
-export declare function tool<TSchema extends z.ZodObject>(name: string, description: string, schema: TSchema, handler: ToolHandler<z.infer<TSchema>>): LocalToolDefinition<TSchema>;
+export declare function tool<TSchema extends z.ZodObject>(definition: LocalToolDefinition<TSchema>): LocalToolDefinition<TSchema>;
 export declare function localTools(tools: LocalToolDefinition<z.ZodObject>[]): ToolProvider;

package/dist/tools/local-tools.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-export function tool(name, description, schema, handler) {
-    return { name, description, schema, handler };
+export function tool(definition) {
+    return { ...definition };
 }
 const zodToJsonSchema = (schema) => {
     const fullSchema = z.toJSONSchema(schema);

package/dist/utils/prompt.d.ts

@@ -0,0 +1,7 @@
+export type SystemPrompt = {
+    prompt: string;
+    name?: string;
+    version?: string;
+};
+export type SystemPromptProp = string | SystemPrompt | (() => Promise<SystemPrompt> | SystemPrompt);
+export declare const getSystemPrompt: (systemPrompt?: SystemPromptProp) => Promise<SystemPrompt | undefined>;

package/dist/utils/prompt.js

@@ -0,0 +1,12 @@
+export const getSystemPrompt = async (systemPrompt) => {
+    if (!systemPrompt) {
+        return undefined;
+    }
+    if (typeof systemPrompt === 'string') {
+        return { prompt: systemPrompt };
+    }
+    if (typeof systemPrompt === 'function') {
+        return await systemPrompt();
+    }
+    return systemPrompt;
+};

package/dist/utils/recursive-merge.d.ts

@@ -0,0 +1,7 @@
+import { type Observable } from 'rxjs';
+export declare function recursiveMerge<S, E>(initial: S, eventsFor: (state: S & {
+    iteration: number;
+}) => Observable<E>, next: (state: S, info: {
+    iteration: number;
+    events: E[];
+}) => S, isStop: (e: E) => boolean): Observable<E>;

package/dist/utils/recursive-merge.js

@@ -0,0 +1,29 @@
+import { EMPTY, expand, map, mergeMap, of, reduce, share, shareReplay, } from 'rxjs';
+export function recursiveMerge(initial, eventsFor, next, isStop) {
+    const seed = {
+        state: initial,
+        iteration: 0,
+        events$: eventsFor({ ...initial, iteration: 0 }).pipe(shareReplay()),
+    };
+    const iterations$ = of(seed).pipe(expand(({ state, iteration, events$ }) => events$.pipe(reduce((acc, e) => {
+        acc.events.push(e);
+        if (isStop(e))
+            acc.sawStop = true;
+        return acc;
+    }, { events: [], sawStop: false }), mergeMap(({ events, sawStop }) => {
+        if (sawStop)
+            return EMPTY;
+        return of(next(state, { iteration, events })).pipe(map((nextState) => {
+            const nextIter = iteration + 1;
+            return {
+                state: nextState,
+                iteration: nextIter,
+                events$: eventsFor({
+                    ...nextState,
+                    iteration: nextIter,
+                }).pipe(share()),
+            };
+        }));
+    }))));
+    return iterations$.pipe(mergeMap(({ events$ }) => events$));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looopy-ai/core",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "RxJS-based AI agent framework",
   "keywords": [
     "agent",