@mozaik-ai/core 0.9.4 → 2.0.1

package/dist/index.d.ts

@@ -1,132 +1,148 @@
-import { ZodObject } from 'zod';
-
-declare class Workflow extends WorkUnit {
-    readonly mode: "parallel" | "sequential";
-    readonly units: WorkUnit[];
-    constructor(mode: "parallel" | "sequential", units: WorkUnit[]);
-    execute(hook?: ExecutionHook): Promise<any>;
+declare abstract class ContextItem {
+    abstract readonly type: string;
+    getType(): string;
+    abstract toJSON(): any;
 }
 
-declare class Task extends WorkUnit {
-    private task;
-    private model;
-    constructor(task: string, model: Model);
-    getTask(): string;
-    getModel(): Model;
-    execute(hook?: ExecutionHook): Promise<any>;
+declare class Context {
+    readonly id: string;
+    readonly projectId: string;
+    readonly items: ContextItem[];
+    constructor(id: string, projectId: string, items: ContextItem[]);
+    addItem(item: ContextItem): Context;
+    addItems(items: ContextItem[]): Context;
+    getItems(): ContextItem[];
+    static create(projectId: string): Context;
+    static rehydrate(data: {
+        id: string;
+        projectId: string;
+        items: ContextItem[];
+    }): Context;
+    toJSON(): any;
 }
 
-interface ExecutionHook {
-    beforeWorkflow(wf: Workflow): void;
-    afterWorkflow(wf: Workflow, result: any): void;
-    beforeTask(task: Task): void;
-    afterTask(task: Task, result: any): void;
+declare abstract class Content {
+    abstract readonly type: string;
 }
 
-declare abstract class WorkUnit {
-    constructor();
-    abstract execute(hook: ExecutionHook): Promise<any>;
+declare class InputText extends Content {
+    readonly text: string;
+    readonly type = "input_text";
+    private constructor();
+    static create(text: string): InputText;
+    static rehydrate(data: {
+        text: string;
+    }): InputText;
+    toJSON(): any[];
 }
 
-interface TextPart {
-    type: "text";
-    text: string;
-}
-interface ImagePart {
-    type: "image_url";
-    url: string;
-}
-interface Message {
-    role: "system" | "user" | "assistant" | "tool";
-    content: string | Array<TextPart | ImagePart>;
+declare class UserMessage extends ContextItem {
+    readonly type = "message";
+    readonly role = "user";
+    readonly content: InputText;
+    private constructor();
+    static create(text: string): UserMessage;
+    static rehydrate(data: {
+        text: string;
+    }): UserMessage;
+    toJSON(): any;
 }
 
-declare const OPENAI_MODELS: readonly ["gpt-5", "gpt-5-mini", "gpt-5-nano", "gpt-5.1", "gpt-5.2", "gpt-5.4"];
-type OpenAIModel = (typeof OPENAI_MODELS)[number];
-declare const ANTHROPIC_MODELS: readonly ["claude-sonnet-4.5", "claude-haiku-4.5", "claude-opus-4.5"];
-type AnthropicModel = (typeof ANTHROPIC_MODELS)[number];
-type Model = OpenAIModel | AnthropicModel;
-
-interface Tool {
-    name: string;
-    description: string;
-    schema: Record<string, any>;
-    invoke: (args: any) => Promise<any>;
+declare class DeveloperMessage extends ContextItem {
+    readonly type = "message";
+    readonly role = "developer";
+    readonly content: InputText;
+    private constructor();
+    toJSON(): any;
+    static create(text: string): DeveloperMessage;
+    static rehydrate(data: {
+        text: string;
+    }): DeveloperMessage;
 }
 
-type MozaikRequest = {
-    model: Model;
-    messages?: Message[];
-    task?: string;
-    structuredOutput?: ZodObject<any>;
-    tools?: Tool[];
-    reasoningEffort?: ReasoningEffort;
-};
-declare enum ReasoningEffort {
-    NONE = "none",
-    LOW = "low",
-    MEDIUM = "medium",
-    HIGH = "high",
-    MAX = "max"
+declare class OutputText extends Content {
+    readonly text: string;
+    readonly type = "output_text";
+    private constructor();
+    static rehydrate(data: {
+        text: string;
+    }): OutputText;
+    toJSON(): any[];
 }
 
-declare abstract class RequestBuilder {
-    request: any;
-    initialize(): void;
-    abstract addModel(model: string): RequestBuilder;
-    abstract addTask(task: string): RequestBuilder;
-    abstract addMessages(messages: Message[]): RequestBuilder;
-    abstract addStructuredOutput(schema: ZodObject<any>): RequestBuilder;
-    abstract addTools(tools: Tool[]): RequestBuilder;
-    abstract addReasoningEffort(effort: ReasoningEffort): RequestBuilder;
-    build(): any;
+declare class ModelMessage extends ContextItem {
+    readonly type = "message";
+    readonly role = "assistant";
+    readonly content: OutputText;
+    private constructor();
+    static rehydrate(data: {
+        text: string;
+    }): ModelMessage;
+    toJSON(): any;
 }
 
-declare abstract class Endpoint {
-    abstract requestBuilder: RequestBuilder;
-    request: MozaikRequest | null;
-    buildRequest(request: MozaikRequest): any;
-    abstract sendRequest(providerRequest: any): any;
+declare class FunctionCall extends ContextItem {
+    readonly type = "function_call";
+    readonly callId: string;
+    readonly name: string;
+    readonly args: string;
+    private constructor();
+    static rehydrate(data: {
+        callId: string;
+        name: string;
+        args: string;
+    }): FunctionCall;
+    toJSON(): any;
 }
 
-declare abstract class EndpointResolver {
-    abstract resolve(model: string): Endpoint;
+declare class SummaryText extends Content {
+    readonly text: string;
+    readonly type = "summary_text";
+    private constructor();
+    static rehydrate(data: {
+        text: string;
+    }): SummaryText;
+    toJSON(): Record<string, any>;
 }
 
-declare class RequestGateway {
-    readonly endpointResolver: EndpointResolver;
-    endpoint: Endpoint;
-    constructor(endpointResolver: EndpointResolver);
-    invoke(request: MozaikRequest): Promise<any>;
+declare class Reasoning extends ContextItem {
+    readonly type = "reasoning";
+    readonly content: InputText | undefined;
+    readonly encryptedContent: string | undefined;
+    readonly summary: SummaryText[];
+    private constructor();
+    static rehydrate(data: {
+        content: InputText | undefined;
+        encryptedContent: string | undefined;
+        summary: SummaryText[];
+    }): Reasoning;
+    toJSON(): any;
 }
 
-declare class MozaikAgent {
-    private request;
-    gateway: RequestGateway;
-    constructor(request: MozaikRequest);
-    setModel(model: Model): void;
-    setMessages(messages: Message[]): void;
-    setTask(task: string): void;
-    setStructuredOutput(schema: ZodObject<any>): void;
-    act(task?: string): Promise<any>;
+declare abstract class GenerativeModel {
+    abstract mapContextToRequest(context: Context): any[];
+    abstract extractContextItems(response: any): ContextItem[];
+    abstract infer(request: any): Promise<any>;
+    call(context: Context): Promise<ContextItem[]>;
 }
 
-declare class PlanningAgent extends MozaikAgent {
-    constructor(request: MozaikRequest);
-    planFromGoal(goal: string): Promise<Workflow>;
+declare class FunctionCallOutput extends ContextItem {
+    readonly type = "function_call_output";
+    readonly callId: string;
+    readonly output: InputText[];
+    private constructor();
+    static create(callId: string, output: InputText[]): FunctionCallOutput;
+    static rehydrate(data: {
+        callId: string;
+        output: InputText[];
+    }): FunctionCallOutput;
+    toJSON(): any;
 }
 
-type UsageEntry = {
-    inputTokens: number;
-    outputTokens: number;
-    model: string;
-};
-type MozaikResponse = {
-    data: any;
-    usage: {
-        entries: UsageEntry[];
-        totalUsdCost: number;
-    };
-};
+interface ContextRepository {
+    save(context: Context): Promise<void>;
+    get(id: string): Promise<Context>;
+    getByProjectId(projectId: string): Promise<Context[]>;
+}
 
-export { type Message, type Model, MozaikAgent, type MozaikRequest, type MozaikResponse, PlanningAgent, ReasoningEffort, Task, type Tool, WorkUnit, Workflow };
+export { Context, ContextItem, type ContextRepository, DeveloperMessage, FunctionCall, FunctionCallOutput, GenerativeModel, ModelMessage, Reasoning, UserMessage };