@polka-codes/core 0.9.51 → 0.9.53

package/README.md

@@ -8,7 +8,7 @@ Core AI services and agent implementations for Polka Codes framework.
 
 ## Features
 
-- Multiple AI provider support (Ollama, Anthropic, DeepSeek)
+- Multiple AI provider support (Anthropic, DeepSeek, GoogleVertex, Ollama, OpenAI, and OpenRouter)
 - Extensible agent architecture
 - Tool integration system
 - Type-safe API
@@ -22,82 +22,80 @@ bun add @polka-codes/core
 
 ## Usage
 
-### Basic Setup
+The core of `@polka-codes/core` is the `agentWorkflow`. You can use it to create a workflow that interacts with an AI model.
 
 ```typescript
-import { AgentBase } from '@polka-codes/core';
-
-class MyAgent extends AgentBase {
-  // Implement your agent logic
-}
-
-const agent = new MyAgent();
-await agent.runTask('your-task');
-```
-
-### Available Services
-
-- `AnthropicService`: Integration with Anthropic API
-- `DeepSeekService`: Integration with DeepSeek API
-- `OllamaService`: Integration with Ollama API
-
-### Tools
-
-The core package provides a tool system for extending functionality:
-
-```typescript
-import { ToolBase } from '@polka-codes/core';
-
-class MyTool extends ToolBase {
-  // Implement your tool logic
+import {
+  agentWorkflow,
+  createContext,
+  makeStepFn,
+  type ToolResponse,
+  ToolResponseType,
+} from '@polka-codes/core';
+import { z } from 'zod';
+
+// Define a tool
+const getCurrentWeather = {
+  name: 'getCurrentWeather',
+  description: 'Get the current weather in a given location',
+  parameters: z.object({
+    location: z.string().describe("The city and state, e.g. San Francisco, CA"),
+  }),
+};
+
+async function main() {
+  // Create a context for the workflow
+  const context = createContext({
+    // Implement the tool
+    invokeTool: async ({ toolName, input }) => {
+      if (toolName === 'getCurrentWeather') {
+        const { location } = input as z.infer<typeof getCurrentWeather.parameters>;
+        // In a real app, you would call a weather API here
+        const weather = `The weather in ${location} is 70°F and sunny.`;
+        const response: ToolResponse = { type: ToolResponseType.Reply, message: weather };
+        return response;
+      }
+      const response: ToolResponse = { type: ToolResponseType.Error, message: 'Tool not found' };
+      return response;
+    },
+    // A simple text generation function
+    generateText: async ({ messages }) => {
+        // In a real app, you would call an AI provider here (e.g. Anthropic, OpenAI)
+        console.log('--- Assistant Turn ---');
+        console.log(messages);
+        // This is a mock response for demonstration purposes
+        return [{
+          role: 'assistant',
+          content: [{
+            type: 'tool-call',
+            toolName: 'getCurrentWeather',
+            toolCallId: '123',
+            input: { location: 'San Francisco, CA' }
+          }]
+        }];
+    },
+    taskEvent: async (event) => {
+      console.log('Task Event:', event.kind);
+    }
+  }, makeStepFn());
+
+  // Run the agent workflow
+  const result = await agentWorkflow(
+    {
+      tools: [getCurrentWeather],
+      systemPrompt: "You are a helpful assistant.",
+      userMessage: [{ role: 'user', content: "What's the weather in San Francisco, CA?" }],
+    },
+    context
+  );
+
+  console.log('--- Workflow Result ---');
+  console.log(result);
 }
-```
-
-### Nested workflows
 
-You can reuse existing workflows inside other workflows with the `workflow` step. This is helpful when you want to repeat a
-common CLI pattern such as `custom → agent → custom`.
-
-```typescript
-import {
-  builder,
-  combineHandlers,
-  customStepSpecHandler,
-  makeAgentStepSpecHandler,
-  sequentialStepSpecHandler,
-  workflowStepSpecHandler,
-} from '@polka-codes/core/workflow';
-
-const reviewWorkflow = builder<{ code: string }>()
-  .custom('prepare', async ({ code }) => ({ prompt: `Review this snippet:\n${code}` }))
-  .agent('agent', {
-    messages: [{ type: 'function', fn: (input) => input.prompt }],
-    systemPrompt: 'You are a careful reviewer.',
-    parseOutput: (raw) => ({ success: true, data: { review: raw } }),
-  })
-  .custom('summarize', async (input) => ({ summary: input.review }))
-  .build();
-
-const mainWorkflow = builder<{ code: string; notify: boolean }>()
-  .workflow('review', {
-    workflow: reviewWorkflow,
-    mapInput: (input) => ({ code: input.code }),
-    mapOutput: ({ workflowOutput, input }) => ({ summary: workflowOutput.summary, notify: input.notify }),
-  })
-  .custom('finalize', async ({ summary, notify }) => ({ summary, notified: notify }))
-  .build();
-
-const handlers = combineHandlers(
-  sequentialStepSpecHandler,
-  customStepSpecHandler,
-  workflowStepSpecHandler,
-  makeAgentStepSpecHandler(async () => /* return a LanguageModelV2 */ throw new Error('model not configured')),
-);
+main();
 ```
 
-The optional `mapInput` and `mapOutput` helpers let you shape data for the child workflow and massage the result before the
-next parent step runs.
-
 ## Development
 
 ### Building

package/dist/_tsup-dts-rollup.d.ts

@@ -5,7 +5,15 @@ import type { JSONValue } from '@ai-sdk/provider';
 import type { LanguageModelV2 } from '@ai-sdk/provider';
 import type { LanguageModelV2ToolResultOutput } from '@ai-sdk/provider';
 import type { LanguageModelV2Usage } from '@ai-sdk/provider';
+import type { ModelMessage } from '@ai-sdk/provider-utils';
+import type { ProviderOptions } from '@ai-sdk/provider-utils';
+import type { ReasoningPart } from '@ai-sdk/provider-utils';
+import type { SystemModelMessage } from '@ai-sdk/provider-utils';
 import type { TextPart } from 'ai';
+import type { TextPart as TextPart_2 } from '@ai-sdk/provider-utils';
+import type { ToolModelMessage } from '@ai-sdk/provider-utils';
+import type { ToolResultPart } from '@ai-sdk/provider-utils';
+import { ToolSet } from 'ai';
 import { z } from 'zod';
 import { ZodEnum } from 'zod';
 import { ZodNullable } from 'zod';
@@ -13,6 +21,51 @@ import { ZodObject } from 'zod';
 import { ZodOptional } from 'zod';
 import { ZodString } from 'zod';
 
+declare type AgentToolRegistry = {
+    generateText: {
+        input: {
+            messages: JsonModelMessage[];
+            tools: ToolSet;
+            model?: string;
+        };
+        output: JsonResponseMessage[];
+    };
+    taskEvent: {
+        input: TaskEvent;
+        output: void;
+    };
+    invokeTool: {
+        input: {
+            toolName: string;
+            input: any;
+        };
+        output: ToolResponse;
+    };
+};
+export { AgentToolRegistry }
+export { AgentToolRegistry as AgentToolRegistry_alias_1 }
+export { AgentToolRegistry as AgentToolRegistry_alias_2 }
+
+declare const agentWorkflow: WorkflowFn<AgentWorkflowInput, ExitReason, AgentToolRegistry>;
+export { agentWorkflow }
+export { agentWorkflow as agentWorkflow_alias_1 }
+export { agentWorkflow as agentWorkflow_alias_2 }
+
+declare type AgentWorkflowInput = {
+    tools: Readonly<FullToolInfo[]>;
+    maxToolRoundTrips?: number;
+    userMessage: JsonUserModelMessage[];
+    outputSchema?: z.ZodSchema;
+    model?: string;
+} & ({
+    messages: JsonModelMessage[];
+} | {
+    systemPrompt: string;
+});
+export { AgentWorkflowInput }
+export { AgentWorkflowInput as AgentWorkflowInput_alias_1 }
+export { AgentWorkflowInput as AgentWorkflowInput_alias_2 }
+
 declare type CommandProvider = {
     executeCommand?: (command: string, needApprove: boolean) => Promise<{
         stdout: string;
@@ -83,6 +136,11 @@ declare const configSchema: z.ZodObject<{
 export { configSchema }
 export { configSchema as configSchema_alias_1 }
 
+declare function createContext<TTools extends ToolRegistry>(tools: WorkflowTools<TTools>, stepFn?: <T>(name: string, fn: () => Promise<T>) => Promise<T>, logger?: Logger): WorkflowContext<TTools>;
+export { createContext }
+export { createContext as createContext_alias_1 }
+export { createContext as createContext_alias_2 }
+
 declare const _default: {
     handler: ToolHandler<{
         readonly name: "askFollowupQuestion";
@@ -463,6 +521,26 @@ export { _default_9 as readFile_alias_1 }
  */
 export declare function dirname(path: string): string;
 
+declare type ExitReason = {
+    type: 'UsageExceeded';
+    messages: JsonModelMessage[];
+} | {
+    type: 'Exit';
+    message: string;
+    object?: any;
+    messages: JsonModelMessage[];
+} | {
+    type: 'Error';
+    error: {
+        message: string;
+        stack?: string;
+    };
+    messages: JsonModelMessage[];
+};
+export { ExitReason }
+export { ExitReason as ExitReason_alias_1 }
+export { ExitReason as ExitReason_alias_2 }
+
 declare type FilesystemProvider = {
     readFile?: (path: string, includeIgnored: boolean) => Promise<string | undefined>;
     writeFile?: (path: string, content: string) => Promise<void>;
@@ -479,6 +557,11 @@ export { FilesystemProvider }
 export { FilesystemProvider as FilesystemProvider_alias_1 }
 export { FilesystemProvider as FilesystemProvider_alias_2 }
 
+declare const fromJsonModelMessage: (msg: JsonModelMessage) => ModelMessage;
+export { fromJsonModelMessage }
+export { fromJsonModelMessage as fromJsonModelMessage_alias_1 }
+export { fromJsonModelMessage as fromJsonModelMessage_alias_2 }
+
 declare type FullToolInfo = ToolInfo & {
     handler: ToolHandler<ToolInfo, any>;
 };
@@ -541,11 +624,171 @@ export { InteractionProvider as InteractionProvider_alias_2 }
  */
 export declare function join(...parts: string[]): string;
 
+/**
+ Content of an assistant message.
+ It can be a string or an array of text, image, reasoning, redacted reasoning, and tool call parts.
+ */
+declare type JsonAssistantContent = string | Array<TextPart_2 | JsonFilePart | ReasoningPart | JsonToolCallPart | ToolResultPart>;
+
+/**
+ An assistant message. It can contain text, tool calls, or a combination of text and tool calls.
+ */
+declare type JsonAssistantModelMessage = {
+    role: 'assistant';
+    content: JsonAssistantContent;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+};
+
+declare type JsonDataContent = {
+    type: 'base64' | 'url';
+    value: string;
+};
+
+/**
+ File content part of a prompt. It contains a file.
+ */
+declare interface JsonFilePart {
+    type: 'file';
+    /**
+     File data. Can either be:
+
+     - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+     - URL: a URL that points to the image
+     */
+    data: JsonDataContent;
+    /**
+     Optional filename of the file.
+     */
+    filename?: string;
+    /**
+     IANA media type of the file.
+
+     @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType: string;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+}
+export { JsonFilePart }
+export { JsonFilePart as JsonFilePart_alias_1 }
+export { JsonFilePart as JsonFilePart_alias_2 }
+
+declare interface JsonImagePart {
+    type: 'image';
+    /**
+     Image data. Can either be:
+
+     - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+     - URL: a URL that points to the image
+     */
+    image: JsonDataContent;
+    /**
+     Optional IANA media type of the image.
+
+     @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType?: string;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+}
+export { JsonImagePart }
+export { JsonImagePart as JsonImagePart_alias_1 }
+export { JsonImagePart as JsonImagePart_alias_2 }
+
+declare type JsonModelMessage = SystemModelMessage | JsonUserModelMessage | JsonAssistantModelMessage | ToolModelMessage;
+export { JsonModelMessage }
+export { JsonModelMessage as JsonModelMessage_alias_1 }
+export { JsonModelMessage as JsonModelMessage_alias_2 }
+
+declare type JsonResponseMessage = JsonAssistantModelMessage | ToolModelMessage;
+export { JsonResponseMessage }
+export { JsonResponseMessage as JsonResponseMessage_alias_1 }
+export { JsonResponseMessage as JsonResponseMessage_alias_2 }
+
+declare interface JsonToolCallPart {
+    type: 'tool-call';
+    /**
+     ID of the tool call. This ID is used to match the tool call with the tool result.
+     */
+    toolCallId: string;
+    /**
+     Name of the tool that is being called.
+     */
+    toolName: string;
+    /**
+     Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+     */
+    input: JSONValue;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+    /**
+     Whether the tool call was executed by the provider.
+     */
+    providerExecuted?: boolean;
+}
+
+/**
+ Content of a user message. It can be a string or an array of text and image parts.
+ */
+declare type JsonUserContent = string | Array<TextPart_2 | JsonImagePart | JsonFilePart>;
+export { JsonUserContent }
+export { JsonUserContent as JsonUserContent_alias_1 }
+export { JsonUserContent as JsonUserContent_alias_2 }
+
+/**
+ A user message. It can contain text or a combination of text and images.
+ */
+declare type JsonUserModelMessage = {
+    role: 'user';
+    content: JsonUserContent;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+};
+export { JsonUserModelMessage }
+export { JsonUserModelMessage as JsonUserModelMessage_alias_1 }
+export { JsonUserModelMessage as JsonUserModelMessage_alias_2 }
+
 declare type ListTodoItemsOutput = TodoItem[];
 export { ListTodoItemsOutput }
 export { ListTodoItemsOutput as ListTodoItemsOutput_alias_1 }
 export { ListTodoItemsOutput as ListTodoItemsOutput_alias_2 }
 
+declare interface Logger {
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+export { Logger }
+export { Logger as Logger_alias_1 }
+export { Logger as Logger_alias_2 }
+
+declare const makeStepFn: () => (<T>(name: string, fn: () => Promise<T>) => Promise<T>);
+export { makeStepFn }
+export { makeStepFn as makeStepFn_alias_1 }
+export { makeStepFn as makeStepFn_alias_2 }
+
 declare interface MemoryProvider {
     listMemoryTopics: () => Promise<string[]>;
     readMemory: (topic?: string) => Promise<string | undefined>;
@@ -637,6 +880,143 @@ export { responsePrompts }
 export { responsePrompts as responsePrompts_alias_1 }
 export { responsePrompts as responsePrompts_alias_2 }
 
+/**
+ * Union type of all possible task events
+ */
+declare type TaskEvent = TaskEventStartTask | TaskEventStartRequest | TaskEventEndRequest | TaskEventText | TaskEventToolUse | TaskEventToolResult | TaskEventToolError | TaskEventUsageExceeded | TaskEventEndTask;
+export { TaskEvent }
+export { TaskEvent as TaskEvent_alias_1 }
+export { TaskEvent as TaskEvent_alias_2 }
+
+/**
+ * Base interface for all task events
+ */
+declare interface TaskEventBase {
+    kind: TaskEventKind;
+}
+export { TaskEventBase }
+export { TaskEventBase as TaskEventBase_alias_1 }
+export { TaskEventBase as TaskEventBase_alias_2 }
+
+declare type TaskEventCallback = (event: TaskEvent) => void | Promise<void>;
+export { TaskEventCallback }
+export { TaskEventCallback as TaskEventCallback_alias_1 }
+export { TaskEventCallback as TaskEventCallback_alias_2 }
+
+/**
+ * Event for request end
+ */
+declare interface TaskEventEndRequest extends TaskEventBase {
+    kind: TaskEventKind.EndRequest;
+    message: string;
+}
+export { TaskEventEndRequest }
+export { TaskEventEndRequest as TaskEventEndRequest_alias_1 }
+export { TaskEventEndRequest as TaskEventEndRequest_alias_2 }
+
+/**
+ * Event for task end
+ */
+declare interface TaskEventEndTask extends TaskEventBase {
+    kind: TaskEventKind.EndTask;
+    exitReason: ExitReason;
+}
+export { TaskEventEndTask }
+export { TaskEventEndTask as TaskEventEndTask_alias_1 }
+export { TaskEventEndTask as TaskEventEndTask_alias_2 }
+
+/**
+ * Enum representing different kinds of task events
+ */
+declare enum TaskEventKind {
+    StartTask = "StartTask",
+    StartRequest = "StartRequest",
+    EndRequest = "EndRequest",
+    Text = "Text",
+    Reasoning = "Reasoning",
+    ToolUse = "ToolUse",
+    ToolReply = "ToolReply",
+    ToolError = "ToolError",
+    UsageExceeded = "UsageExceeded",
+    EndTask = "EndTask"
+}
+export { TaskEventKind }
+export { TaskEventKind as TaskEventKind_alias_1 }
+export { TaskEventKind as TaskEventKind_alias_2 }
+
+/**
+ * Event for request start
+ */
+declare interface TaskEventStartRequest extends TaskEventBase {
+    kind: TaskEventKind.StartRequest;
+    userMessage: JsonModelMessage[];
+}
+export { TaskEventStartRequest }
+export { TaskEventStartRequest as TaskEventStartRequest_alias_1 }
+export { TaskEventStartRequest as TaskEventStartRequest_alias_2 }
+
+/**
+ * Event for task start
+ */
+declare interface TaskEventStartTask extends TaskEventBase {
+    kind: TaskEventKind.StartTask;
+    systemPrompt: string;
+}
+export { TaskEventStartTask }
+export { TaskEventStartTask as TaskEventStartTask_alias_1 }
+export { TaskEventStartTask as TaskEventStartTask_alias_2 }
+
+/**
+ * Event for text/reasoning updates
+ */
+declare interface TaskEventText extends TaskEventBase {
+    kind: TaskEventKind.Text | TaskEventKind.Reasoning;
+    newText: string;
+}
+export { TaskEventText }
+export { TaskEventText as TaskEventText_alias_1 }
+export { TaskEventText as TaskEventText_alias_2 }
+
+declare interface TaskEventToolError extends TaskEventBase {
+    kind: TaskEventKind.ToolError;
+    tool: string;
+    error: ToolResponseError | ToolResponseResult;
+}
+export { TaskEventToolError }
+export { TaskEventToolError as TaskEventToolError_alias_1 }
+export { TaskEventToolError as TaskEventToolError_alias_2 }
+
+declare interface TaskEventToolResult extends TaskEventBase {
+    kind: TaskEventKind.ToolReply;
+    tool: string;
+    content: ToolResponseResult;
+}
+export { TaskEventToolResult }
+export { TaskEventToolResult as TaskEventToolResult_alias_1 }
+export { TaskEventToolResult as TaskEventToolResult_alias_2 }
+
+/**
+ * Event for tool-related updates
+ */
+declare interface TaskEventToolUse extends TaskEventBase {
+    kind: TaskEventKind.ToolUse;
+    tool: string;
+    params: Record<string, any>;
+}
+export { TaskEventToolUse }
+export { TaskEventToolUse as TaskEventToolUse_alias_1 }
+export { TaskEventToolUse as TaskEventToolUse_alias_2 }
+
+/**
+ * Event for task usage exceeded
+ */
+declare interface TaskEventUsageExceeded extends TaskEventBase {
+    kind: TaskEventKind.UsageExceeded;
+}
+export { TaskEventUsageExceeded }
+export { TaskEventUsageExceeded as TaskEventUsageExceeded_alias_1 }
+export { TaskEventUsageExceeded as TaskEventUsageExceeded_alias_2 }
+
 declare type TodoItem = z.infer<typeof TodoItemSchema>;
 export { TodoItem }
 export { TodoItem as TodoItem_alias_1 }
@@ -674,6 +1054,11 @@ export { TodoStatus }
 export { TodoStatus as TodoStatus_alias_1 }
 export { TodoStatus as TodoStatus_alias_2 }
 
+declare const toJsonModelMessage: (msg: ModelMessage) => JsonModelMessage;
+export { toJsonModelMessage }
+export { toJsonModelMessage as toJsonModelMessage_alias_1 }
+export { toJsonModelMessage as toJsonModelMessage_alias_2 }
+
 declare type ToolHandler<_T, P> = (provider: P, args: Partial<Record<string, ToolParameterValue>>) => Promise<ToolResponse>;
 export { ToolHandler }
 export { ToolHandler as ToolHandler_alias_1 }
@@ -878,6 +1263,11 @@ export { ToolProvider }
 export { ToolProvider as ToolProvider_alias_1 }
 export { ToolProvider as ToolProvider_alias_2 }
 
+declare type ToolRegistry = Record<string, ToolSignature<any, any>>;
+export { ToolRegistry }
+export { ToolRegistry as ToolRegistry_alias_1 }
+export { ToolRegistry as ToolRegistry_alias_2 }
+
 declare type ToolResponse = ToolResponseReply | ToolResponseExit | ToolResponseError;
 export { ToolResponse }
 export { ToolResponse as ToolResponse_alias_1 }
@@ -943,6 +1333,14 @@ declare enum ToolResponseType {
 export { ToolResponseType }
 export { ToolResponseType as ToolResponseType_alias_1 }
 
+declare type ToolSignature<I, O> = {
+    input: I;
+    output: O;
+};
+export { ToolSignature }
+export { ToolSignature as ToolSignature_alias_1 }
+export { ToolSignature as ToolSignature_alias_2 }
+
 declare type Totals = {
     input: number;
     output: number;
@@ -1048,4 +1446,25 @@ export { WebProvider }
 export { WebProvider as WebProvider_alias_1 }
 export { WebProvider as WebProvider_alias_2 }
 
+declare type WorkflowContext<TTools extends ToolRegistry> = {
+    step: <T>(name: string, fn: () => Promise<T>) => Promise<T>;
+    logger: Logger;
+    tools: WorkflowTools<TTools>;
+};
+export { WorkflowContext }
+export { WorkflowContext as WorkflowContext_alias_1 }
+export { WorkflowContext as WorkflowContext_alias_2 }
+
+declare type WorkflowFn<TInput, TOutput, TTools extends ToolRegistry> = (input: TInput, context: WorkflowContext<TTools>) => Promise<TOutput>;
+export { WorkflowFn }
+export { WorkflowFn as WorkflowFn_alias_1 }
+export { WorkflowFn as WorkflowFn_alias_2 }
+
+declare type WorkflowTools<TTools extends ToolRegistry> = {
+    [K in keyof TTools]: (input: TTools[K]['input']) => Promise<TTools[K]['output']>;
+};
+export { WorkflowTools }
+export { WorkflowTools as WorkflowTools_alias_1 }
+export { WorkflowTools as WorkflowTools_alias_2 }
+
 export { }

package/dist/index.d.ts

@@ -53,3 +53,36 @@ export { UpdateTodoItemOutputSchema } from './_tsup-dts-rollup.js';
 export { UpdateTodoItemOutput } from './_tsup-dts-rollup.js';
 export { ModelInfo_alias_1 as ModelInfo } from './_tsup-dts-rollup.js';
 export { UsageMeter_alias_1 as UsageMeter } from './_tsup-dts-rollup.js';
+export { AgentWorkflowInput } from './_tsup-dts-rollup.js';
+export { AgentToolRegistry } from './_tsup-dts-rollup.js';
+export { agentWorkflow } from './_tsup-dts-rollup.js';
+export { JsonImagePart } from './_tsup-dts-rollup.js';
+export { JsonFilePart } from './_tsup-dts-rollup.js';
+export { JsonUserModelMessage } from './_tsup-dts-rollup.js';
+export { JsonUserContent } from './_tsup-dts-rollup.js';
+export { JsonModelMessage } from './_tsup-dts-rollup.js';
+export { JsonResponseMessage } from './_tsup-dts-rollup.js';
+export { toJsonModelMessage } from './_tsup-dts-rollup.js';
+export { fromJsonModelMessage } from './_tsup-dts-rollup.js';
+export { TaskEventKind } from './_tsup-dts-rollup.js';
+export { TaskEventBase } from './_tsup-dts-rollup.js';
+export { TaskEventStartTask } from './_tsup-dts-rollup.js';
+export { TaskEventStartRequest } from './_tsup-dts-rollup.js';
+export { TaskEventEndRequest } from './_tsup-dts-rollup.js';
+export { TaskEventText } from './_tsup-dts-rollup.js';
+export { TaskEventToolUse } from './_tsup-dts-rollup.js';
+export { TaskEventToolResult } from './_tsup-dts-rollup.js';
+export { TaskEventToolError } from './_tsup-dts-rollup.js';
+export { TaskEventUsageExceeded } from './_tsup-dts-rollup.js';
+export { TaskEventEndTask } from './_tsup-dts-rollup.js';
+export { TaskEvent } from './_tsup-dts-rollup.js';
+export { TaskEventCallback } from './_tsup-dts-rollup.js';
+export { ExitReason } from './_tsup-dts-rollup.js';
+export { createContext } from './_tsup-dts-rollup.js';
+export { Logger } from './_tsup-dts-rollup.js';
+export { ToolSignature } from './_tsup-dts-rollup.js';
+export { ToolRegistry } from './_tsup-dts-rollup.js';
+export { WorkflowTools } from './_tsup-dts-rollup.js';
+export { WorkflowContext } from './_tsup-dts-rollup.js';
+export { WorkflowFn } from './_tsup-dts-rollup.js';
+export { makeStepFn } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -1644,23 +1644,372 @@ var UsageMeter = class {
     };
   }
 };
+
+// src/workflow/agent.workflow.ts
+import { jsonSchema } from "ai";
+import { toJSONSchema, z as z19 } from "zod";
+
+// src/workflow/types.ts
+var TaskEventKind = /* @__PURE__ */ ((TaskEventKind2) => {
+  TaskEventKind2["StartTask"] = "StartTask";
+  TaskEventKind2["StartRequest"] = "StartRequest";
+  TaskEventKind2["EndRequest"] = "EndRequest";
+  TaskEventKind2["Text"] = "Text";
+  TaskEventKind2["Reasoning"] = "Reasoning";
+  TaskEventKind2["ToolUse"] = "ToolUse";
+  TaskEventKind2["ToolReply"] = "ToolReply";
+  TaskEventKind2["ToolError"] = "ToolError";
+  TaskEventKind2["UsageExceeded"] = "UsageExceeded";
+  TaskEventKind2["EndTask"] = "EndTask";
+  return TaskEventKind2;
+})(TaskEventKind || {});
+
+// src/workflow/agent.workflow.ts
+var agentWorkflow = async (input, { step, tools }) => {
+  const event = (name, event2) => step(name, () => tools.taskEvent(event2));
+  const { tools: toolInfo18, maxToolRoundTrips = 200 } = input;
+  const messages = "systemPrompt" in input ? [{ role: "system", content: input.systemPrompt }] : input.messages;
+  await event("start-task", { kind: "StartTask" /* StartTask */, systemPrompt: "systemPrompt" in input ? input.systemPrompt : "" });
+  const toolSet = {};
+  for (const tool of toolInfo18) {
+    toolSet[tool.name] = {
+      description: tool.description,
+      inputSchema: jsonSchema(toJSONSchema(tool.parameters))
+    };
+  }
+  let nextMessage = input.userMessage;
+  for (let i = 0; i < maxToolRoundTrips; i++) {
+    messages.push(...nextMessage);
+    await event(`start-round-${i}`, { kind: "StartRequest" /* StartRequest */, userMessage: nextMessage });
+    const assistantMessage = await step(`agent-round-${i}`, async () => {
+      return await tools.generateText({
+        messages,
+        tools: toolSet,
+        model: input.model
+      });
+    });
+    messages.push(...assistantMessage);
+    const toolCalls = [];
+    for (const msg of assistantMessage) {
+      if (typeof msg.content === "string") {
+        continue;
+      }
+      if (msg.content) {
+        for (const part of msg.content) {
+          if (part.type === "tool-call") {
+            toolCalls.push(part);
+          }
+        }
+      }
+    }
+    const textContent = assistantMessage.flatMap((m) => {
+      if (typeof m.content === "string") {
+        return [m.content];
+      }
+      if (m.role === "assistant" && Array.isArray(m.content)) {
+        return m.content.map((part) => {
+          if (part.type === "text") {
+            return part.text;
+          }
+          return "";
+        });
+      }
+      return [];
+    }).join("\n");
+    await event(`end-round-${i}`, { kind: "EndRequest" /* EndRequest */, message: textContent });
+    if (toolCalls.length === 0) {
+      if (!input.outputSchema) {
+        const exitReason2 = { type: "Exit", message: textContent, messages };
+        await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: exitReason2 });
+        return exitReason2;
+      }
+      const parsed = parseJsonFromMarkdown(textContent);
+      if (!parsed.success) {
+        const errorMessage = `Failed to parse JSON from markdown. Error: ${parsed.error}. Please correct the output. It MUST be in valid JSON format.`;
+        nextMessage = [{ role: "user", content: errorMessage }];
+        continue;
+      }
+      const validated = input.outputSchema.safeParse(parsed.data);
+      if (!validated.success) {
+        const errorMessage = `Output validation failed. Error: ${z19.prettifyError(validated.error)}. Please correct the output.`;
+        nextMessage = [{ role: "user", content: errorMessage }];
+        continue;
+      }
+      const exitReason = { type: "Exit", message: textContent, object: validated.data, messages };
+      await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
+      return exitReason;
+    }
+    const toolResults = [];
+    for (const toolCall of toolCalls) {
+      await event(`event-tool-use-${toolCall.toolName}-${toolCall.toolCallId}`, {
+        kind: "ToolUse" /* ToolUse */,
+        tool: toolCall.toolName,
+        params: toolCall.input
+      });
+      const toolResponse = await step(`invoke-tool-${toolCall.toolName}-${toolCall.toolCallId}`, async () => {
+        return await tools.invokeTool({
+          toolName: toolCall.toolName,
+          input: toolCall.input
+        });
+      });
+      switch (toolResponse.type) {
+        case "Reply" /* Reply */:
+          await event(`event-tool-reply-${toolCall.toolName}-${toolCall.toolCallId}`, {
+            kind: "ToolReply" /* ToolReply */,
+            tool: toolCall.toolName,
+            content: toolResponse.message
+          });
+          toolResults.push({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            output: toolResponse.message
+          });
+          break;
+        case "Error" /* Error */:
+          await event(`event-tool-error-${toolCall.toolName}-${toolCall.toolCallId}`, {
+            kind: "ToolError" /* ToolError */,
+            tool: toolCall.toolName,
+            error: toolResponse.message ?? "Unknown error"
+          });
+          toolResults.push({
+            toolCallId: toolCall.toolCallId,
+            toolName: toolCall.toolName,
+            output: toolResponse.message
+          });
+          break;
+        case "Exit": {
+          if (toolCalls.length > 1) {
+            toolResults.push({
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              output: {
+                type: "error-text",
+                value: `Error: The tool '${toolCall.toolName}' must be called alone, but it was called with other tools.`
+              }
+            });
+            break;
+          }
+          if (toolResults.length > 0) {
+            break;
+          }
+          const exitReason = { ...toolResponse, messages };
+          await event("end-task", { kind: "EndTask" /* EndTask */, exitReason });
+          return exitReason;
+        }
+      }
+    }
+    nextMessage = [
+      {
+        role: "tool",
+        content: toolResults.map((r) => ({
+          type: "tool-result",
+          ...r
+        }))
+      }
+    ];
+  }
+  await event("end-task", { kind: "EndTask" /* EndTask */, exitReason: { type: "UsageExceeded", messages } });
+  throw new Error("Maximum number of tool round trips reached.");
+};
+
+// src/workflow/json-ai-types.ts
+var toJsonDataContent = (data) => {
+  if (data instanceof URL) {
+    return {
+      type: "url",
+      value: data.toString()
+    };
+  }
+  if (typeof data === "string") {
+    return {
+      type: "base64",
+      value: data
+    };
+  }
+  let buffer;
+  if (data instanceof Uint8Array) {
+    buffer = Buffer.from(data);
+  } else if (data instanceof Buffer) {
+    buffer = data;
+  } else {
+    buffer = Buffer.from(data);
+  }
+  return {
+    type: "base64",
+    value: buffer.toString("base64")
+  };
+};
+var toJsonUserContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    switch (part.type) {
+      case "image":
+        return {
+          ...part,
+          image: toJsonDataContent(part.image)
+        };
+      case "file":
+        return {
+          ...part,
+          data: toJsonDataContent(part.data)
+        };
+    }
+    return part;
+  });
+};
+var toJsonAssistantContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    switch (part.type) {
+      case "file":
+        return {
+          ...part,
+          data: toJsonDataContent(part.data)
+        };
+      case "tool-call":
+        return {
+          ...part,
+          input: part.input
+        };
+    }
+    return part;
+  });
+};
+var toJsonModelMessage = (msg) => {
+  switch (msg.role) {
+    case "user":
+      return {
+        ...msg,
+        content: toJsonUserContent(msg.content)
+      };
+    case "assistant":
+      return {
+        ...msg,
+        content: toJsonAssistantContent(msg.content)
+      };
+  }
+  return msg;
+};
+var fromJsonDataContent = (data) => {
+  if (data.type === "url") {
+    return new URL(data.value);
+  }
+  return Buffer.from(data.value, "base64");
+};
+var fromJsonUserContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    switch (part.type) {
+      case "image":
+        return {
+          ...part,
+          image: fromJsonDataContent(part.image)
+        };
+      case "file":
+        return {
+          ...part,
+          data: fromJsonDataContent(part.data)
+        };
+    }
+    return part;
+  });
+};
+var fromJsonAssistantContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    switch (part.type) {
+      case "file":
+        return {
+          ...part,
+          data: fromJsonDataContent(part.data)
+        };
+    }
+    return part;
+  });
+};
+var fromJsonModelMessage = (msg) => {
+  switch (msg.role) {
+    case "system":
+      return msg;
+    case "user":
+      return {
+        ...msg,
+        content: fromJsonUserContent(msg.content)
+      };
+    case "assistant":
+      return {
+        ...msg,
+        content: fromJsonAssistantContent(msg.content)
+      };
+  }
+  return msg;
+};
+
+// src/workflow/workflow.ts
+var silentLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function createContext(tools, stepFn, logger = silentLogger) {
+  if (!stepFn) {
+    stepFn = async (_name, fn) => fn();
+  }
+  return { step: stepFn, logger, tools };
+}
+var makeStepFn = () => {
+  const results = /* @__PURE__ */ new Map();
+  const callStack = [];
+  return async (name, fn) => {
+    callStack.push(name);
+    const key = callStack.join(">");
+    try {
+      if (results.has(key)) {
+        return results.get(key);
+      }
+      const result = await fn();
+      results.set(key, result);
+      return result;
+    } finally {
+      callStack.pop();
+    }
+  };
+};
 export {
   MockProvider,
+  TaskEventKind,
   TodoItemSchema,
   TodoStatus,
   ToolResponseType,
   UpdateTodoItemInputSchema,
   UpdateTodoItemOutputSchema,
   UsageMeter,
+  agentWorkflow,
   askFollowupQuestion_default as askFollowupQuestion,
   computeRateLimitBackoffSeconds,
   configSchema,
+  createContext,
   executeCommand_default as executeCommand,
   fetchUrl_default as fetchUrl,
+  fromJsonModelMessage,
   getTodoItem_default as getTodoItem,
   listFiles_default as listFiles,
   listMemoryTopics_default as listMemoryTopics,
   listTodoItems_default as listTodoItems,
+  makeStepFn,
   parseJsonFromMarkdown,
   readBinaryFile_default as readBinaryFile,
   readFile_default as readFile,
@@ -1671,6 +2020,7 @@ export {
   replaceInFile as replaceInFileHelper,
   responsePrompts,
   searchFiles_default as searchFiles,
+  toJsonModelMessage,
   updateMemory_default as updateMemory,
   updateTodoItem_default as updateTodoItem,
   writeToFile_default as writeToFile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/core",
-  "version": "0.9.51",
+  "version": "0.9.53",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",