veryfront 0.1.286 → 0.1.287

package/esm/src/chat/conversation.js

@@ -0,0 +1,546 @@
+import { z } from "zod";
+const textPartSchema = z.object({ type: z.literal("text"), text: z.string() });
+const imagePartSchema = z.object({
+    type: z.literal("image"),
+    upload_id: z.string().uuid(),
+    media_type: z.string(),
+    url: z.string().optional(),
+});
+const filePartSchema = z.object({
+    type: z.literal("file"),
+    upload_id: z.string().uuid(),
+    media_type: z.string(),
+    filename: z.string().optional(),
+    url: z.string().optional(),
+});
+const toolCallPartSchema = z.object({
+    type: z.literal("tool_call"),
+    id: z.string(),
+    name: z.string(),
+    input: z.record(z.string(), z.unknown()),
+    state: z.enum(["streaming", "pending", "completed", "error"]),
+});
+const toolResultPartSchema = z.object({
+    type: z.literal("tool_result"),
+    tool_call_id: z.string(),
+    output: z.unknown(),
+    is_error: z.boolean().optional(),
+});
+const reasoningPartSchema = z.object({
+    type: z.literal("reasoning"),
+    text: z.string(),
+    signature: z.string().optional(),
+});
+const citationPartSchema = z.object({
+    type: z.literal("citation"),
+    source_id: z.string(),
+    url: z.string().optional(),
+    title: z.string().optional(),
+    quote: z.string().optional(),
+});
+const stepStartPartSchema = z.object({ type: z.literal("step_start") });
+const errorPartSchema = z.object({
+    type: z.literal("error"),
+    code: z.string(),
+    message: z.string(),
+});
+const dataPartSchema = z.object({ type: z.literal("data"), name: z.string(), value: z.unknown() });
+export const messagePartSchema = z.discriminatedUnion("type", [
+    textPartSchema,
+    imagePartSchema,
+    filePartSchema,
+    toolCallPartSchema,
+    toolResultPartSchema,
+    reasoningPartSchema,
+    citationPartSchema,
+    stepStartPartSchema,
+    errorPartSchema,
+    dataPartSchema,
+]);
+export const conversationTypeSchema = z.enum([
+    "chat",
+    "agent_task",
+    "support",
+    "channel",
+    "project_agent",
+]);
+export const messageStatusSchema = z.enum([
+    "pending",
+    "streaming",
+    "completed",
+    "error",
+    "failed",
+    "cancelled",
+    "stopped",
+]);
+export const apiConversationSchema = z.object({
+    id: z.string(),
+    projectId: z.string().nullable().optional(),
+    type: conversationTypeSchema,
+    title: z.string().nullable().optional(),
+    status: z.enum(["active", "archived", "deleted"]),
+    summary: z.string().nullable().optional(),
+    currentNode: z.string().nullable().optional(),
+    messageCount: z.number(),
+    lastMessageAt: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+    createdBy: z.string(),
+    archivedAt: z.string().nullable().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const apiMessageSchema = z.object({
+    id: z.string(),
+    conversationId: z.string(),
+    parentId: z.string().nullable(),
+    seq: z.number(),
+    role: z.enum(["user", "assistant", "tool"]),
+    parts: z.array(messagePartSchema),
+    status: messageStatusSchema,
+    model: z.string().nullable(),
+    tokenUsage: z.object({ input: z.number(), output: z.number() }).nullable(),
+    finishReason: z.string().nullable(),
+    costCredits: z.string().nullable().optional(),
+    createdBy: z.string().nullable(),
+    editedAt: z.string().nullable().optional(),
+    idempotencyKey: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string().nullable(),
+});
+export const UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/i;
+export function isUuid(value) {
+    return typeof value === "string" && UUID_PATTERN.test(value);
+}
+export function extractUploadId(url) {
+    const match = url.match(UUID_PATTERN);
+    return match ? match[0] : null;
+}
+export function mapToolState(sdkState) {
+    switch (sdkState) {
+        case "input-streaming":
+            return "streaming";
+        case "input-available":
+        case "approval-requested":
+        case "approval-responded":
+            return "pending";
+        case "output-available":
+            return "completed";
+        case "output-error":
+        case "output-denied":
+        case "error":
+            return "error";
+        default:
+            return "pending";
+    }
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function getStringField(value, field, fallback) {
+    if (!isRecord(value) || typeof value[field] !== "string") {
+        return fallback;
+    }
+    return value[field];
+}
+function getOptionalStringField(value, key) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const field = value[key];
+    return typeof field === "string" ? field : undefined;
+}
+function getNonEmptyStringField(value, key) {
+    const field = getOptionalStringField(value, key);
+    return field && field.length > 0 ? field : undefined;
+}
+function toRecord(value) {
+    return isRecord(value) ? Object.fromEntries(Object.entries(value)) : {};
+}
+export function stringifyUnknown(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        const serialized = JSON.stringify(value);
+        return serialized ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function isDataUiPart(part) {
+    return part.type.startsWith("data-") && "data" in part;
+}
+export function isToolUiPart(part) {
+    return ((part.type === "dynamic-tool" || part.type.startsWith("tool-")) &&
+        typeof getOptionalStringField(part, "toolCallId") === "string" &&
+        typeof getOptionalStringField(part, "state") === "string");
+}
+export function getUiToolName(part) {
+    const explicitToolName = getOptionalStringField(part, "toolName");
+    if (explicitToolName) {
+        return explicitToolName;
+    }
+    return part.type.startsWith("tool-") ? part.type.replace(/^tool-/, "") : undefined;
+}
+export function pushToolParts(parts, toolName, toolCallId, state, part) {
+    const input = toRecord(part.input);
+    const isErroredState = state === "output-error" || state === "error" || state === "output-denied";
+    const hasResultState = state === "output-available" || isErroredState;
+    if (hasResultState) {
+        parts.push({
+            type: "tool_call",
+            id: toolCallId,
+            name: toolName,
+            input,
+            state: "completed",
+        });
+        const resultOutput = isErroredState
+            ? part.output ?? part.errorText ?? "Tool error"
+            : part.output ?? null;
+        parts.push({
+            type: "tool_result",
+            tool_call_id: toolCallId,
+            output: resultOutput,
+            is_error: isErroredState,
+        });
+        return;
+    }
+    parts.push({
+        type: "tool_call",
+        id: toolCallId,
+        name: toolName,
+        input,
+        state: mapToolState(state),
+    });
+}
+export function isToolCallPart(value) {
+    return (isRecord(value) &&
+        value.type === "tool-call" &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string");
+}
+export function isToolResultPart(value) {
+    return (isRecord(value) &&
+        value.type === "tool-result" &&
+        typeof value.toolCallId === "string" &&
+        typeof value.toolName === "string");
+}
+export function isTextPart(value) {
+    return isRecord(value) && value.type === "text" && typeof value.text === "string";
+}
+export function isReasoningPart(value) {
+    return isRecord(value) && value.type === "reasoning" && typeof value.text === "string";
+}
+export function extractTextFromMessage(message) {
+    if (!message || !message.content)
+        return "";
+    const { content } = message;
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const textParts = [];
+        for (const part of content) {
+            if (isTextPart(part)) {
+                textParts.push(part.text);
+            }
+        }
+        return textParts.join(" ");
+    }
+    return "";
+}
+function toJsonValue(value) {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => toJsonValue(entry));
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, toJsonValue(entry)]));
+    }
+    return JSON.stringify(value);
+}
+function getFilePart(part) {
+    if (!isRecord(part) || part.type !== "file") {
+        return null;
+    }
+    const mediaType = getNonEmptyStringField(part, "mediaType");
+    const data = getNonEmptyStringField(part, "url");
+    if (!mediaType || !data) {
+        return null;
+    }
+    const filename = getNonEmptyStringField(part, "filename");
+    const uploadId = getNonEmptyStringField(part, "uploadId");
+    const uploadPath = getNonEmptyStringField(part, "uploadPath");
+    return {
+        type: "file",
+        mediaType,
+        data,
+        url: data,
+        ...(filename ? { filename } : {}),
+        ...(uploadId ? { uploadId } : {}),
+        ...(uploadPath ? { uploadPath } : {}),
+    };
+}
+function getToolPart(part) {
+    if (!isRecord(part) || typeof part.type !== "string") {
+        return null;
+    }
+    const type = part.type;
+    const toolCallId = getNonEmptyStringField(part, "toolCallId");
+    const state = getNonEmptyStringField(part, "state");
+    const explicitToolName = getNonEmptyStringField(part, "toolName") ??
+        getNonEmptyStringField(part, "name");
+    const derivedToolName = type === "dynamic-tool" || type === "tool_call" || !type.startsWith("tool-")
+        ? undefined
+        : type.replace(/^tool-/, "");
+    const toolName = explicitToolName ?? derivedToolName;
+    if (!toolCallId || !state || !toolName) {
+        return null;
+    }
+    const errorText = getOptionalStringField(part, "errorText");
+    const output = Object.hasOwn(part, "output") ? part.output : undefined;
+    return {
+        toolCallId,
+        toolName,
+        input: toRecord(part.input),
+        state,
+        ...(output !== undefined ? { output } : {}),
+        ...(errorText !== undefined ? { errorText } : {}),
+    };
+}
+function getRawToolCallPart(part) {
+    if (!isRecord(part) || part.type !== "tool_call") {
+        return null;
+    }
+    const toolCallId = getNonEmptyStringField(part, "toolCallId") ??
+        getNonEmptyStringField(part, "tool_call_id") ??
+        getNonEmptyStringField(part, "id");
+    const toolName = getNonEmptyStringField(part, "toolName") ??
+        getNonEmptyStringField(part, "tool_name") ??
+        getNonEmptyStringField(part, "name");
+    if (!toolCallId || !toolName) {
+        return null;
+    }
+    return {
+        toolCallId,
+        toolName,
+        input: toRecord(part.input),
+    };
+}
+function getRawToolResultPart(part) {
+    if (!isRecord(part) || part.type !== "tool_result") {
+        return null;
+    }
+    const toolCallId = getNonEmptyStringField(part, "toolCallId") ??
+        getNonEmptyStringField(part, "tool_call_id") ??
+        getNonEmptyStringField(part, "id");
+    if (!toolCallId) {
+        return null;
+    }
+    const toolName = getNonEmptyStringField(part, "toolName") ??
+        getNonEmptyStringField(part, "tool_name") ??
+        getNonEmptyStringField(part, "name");
+    const isError = part.is_error === true || part.isError === true;
+    const output = isError
+        ? {
+            type: "error-text",
+            value: stringifyUnknown(part.output ?? "Tool error"),
+        }
+        : {
+            type: "json",
+            value: toJsonValue(part.output),
+        };
+    return {
+        toolCallId,
+        ...(toolName ? { toolName } : {}),
+        output,
+    };
+}
+function buildRawToolNameMap(parts) {
+    const toolNames = new Map();
+    for (const part of parts) {
+        const rawToolCall = getRawToolCallPart(part);
+        if (!rawToolCall) {
+            continue;
+        }
+        toolNames.set(rawToolCall.toolCallId, rawToolCall.toolName);
+    }
+    return toolNames;
+}
+function buildToolResultOutput(toolPart) {
+    if (toolPart.state === "output-available") {
+        return {
+            type: "json",
+            value: toJsonValue(toolPart.output),
+        };
+    }
+    if (toolPart.state === "output-error" || toolPart.state === "output-denied" ||
+        toolPart.state === "error") {
+        return {
+            type: "error-text",
+            value: toolPart.errorText ?? stringifyUnknown(toolPart.output ?? "Tool error"),
+        };
+    }
+    return null;
+}
+function convertSystemMessage(message) {
+    const content = message.parts.flatMap((part) => (isTextPart(part) ? [part.text] : [])).join("");
+    if (content.length === 0) {
+        return [];
+    }
+    return [
+        {
+            role: "system",
+            content,
+        },
+    ];
+}
+function convertUserMessage(message) {
+    const content = [];
+    for (const part of message.parts) {
+        if (isTextPart(part)) {
+            content.push({ type: "text", text: part.text });
+            continue;
+        }
+        const filePart = getFilePart(part);
+        if (filePart) {
+            content.push(filePart);
+        }
+    }
+    if (content.length === 0) {
+        return [];
+    }
+    return [
+        {
+            role: "user",
+            content,
+        },
+    ];
+}
+function convertAssistantMessage(message) {
+    const rawToolNamesById = buildRawToolNameMap(message.parts);
+    const assistantContent = [];
+    const deferredAssistantContent = [];
+    const toolResults = [];
+    const pendingToolCallIds = new Set();
+    const messages = [];
+    const flushAssistantMessage = (content) => {
+        if (content.length === 0) {
+            return;
+        }
+        messages.push({
+            role: "assistant",
+            content: [...content],
+        });
+        content.length = 0;
+    };
+    const flushToolMessage = () => {
+        if (toolResults.length === 0) {
+            return;
+        }
+        messages.push({
+            role: "tool",
+            content: [...toolResults],
+        });
+        toolResults.length = 0;
+    };
+    const pushAssistantPart = (part) => {
+        if (toolResults.length > 0) {
+            flushToolMessage();
+            flushAssistantMessage(deferredAssistantContent);
+        }
+        if (part.type === "tool-call") {
+            assistantContent.push(part);
+            pendingToolCallIds.add(part.toolCallId);
+            return;
+        }
+        if (pendingToolCallIds.size > 0) {
+            deferredAssistantContent.push(part);
+            return;
+        }
+        assistantContent.push(part);
+    };
+    const pushToolResult = (part) => {
+        flushAssistantMessage(assistantContent);
+        toolResults.push(part);
+        pendingToolCallIds.delete(part.toolCallId);
+    };
+    for (const part of message.parts) {
+        if (isTextPart(part)) {
+            pushAssistantPart({ type: "text", text: part.text });
+            continue;
+        }
+        if (isReasoningPart(part)) {
+            pushAssistantPart({ type: "reasoning", text: part.text });
+            continue;
+        }
+        const filePart = getFilePart(part);
+        if (filePart) {
+            pushAssistantPart(filePart);
+            continue;
+        }
+        const toolPart = getToolPart(part);
+        if (toolPart) {
+            pushAssistantPart({
+                type: "tool-call",
+                toolCallId: toolPart.toolCallId,
+                toolName: toolPart.toolName,
+                input: toolPart.input,
+            });
+            const resultOutput = buildToolResultOutput(toolPart);
+            if (resultOutput) {
+                pushToolResult({
+                    type: "tool-result",
+                    toolCallId: toolPart.toolCallId,
+                    toolName: toolPart.toolName,
+                    output: resultOutput,
+                });
+            }
+            continue;
+        }
+        const rawToolCall = getRawToolCallPart(part);
+        if (rawToolCall) {
+            pushAssistantPart({
+                type: "tool-call",
+                toolCallId: rawToolCall.toolCallId,
+                toolName: rawToolCall.toolName,
+                input: rawToolCall.input,
+            });
+            continue;
+        }
+        const rawToolResult = getRawToolResultPart(part);
+        if (rawToolResult) {
+            pushToolResult({
+                type: "tool-result",
+                toolCallId: rawToolResult.toolCallId,
+                toolName: rawToolResult.toolName ?? rawToolNamesById.get(rawToolResult.toolCallId) ??
+                    "unknown",
+                output: rawToolResult.output,
+            });
+        }
+    }
+    flushAssistantMessage(assistantContent);
+    flushToolMessage();
+    flushAssistantMessage(deferredAssistantContent);
+    return messages;
+}
+export function convertUiMessagesToModelMessages(messages) {
+    return messages.flatMap((message) => {
+        switch (message.role) {
+            case "system":
+                return convertSystemMessage(message);
+            case "user":
+                return convertUserMessage(message);
+            case "assistant":
+                return convertAssistantMessage(message);
+            default:
+                return [];
+        }
+    });
+}

package/esm/src/utils/version-constant.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.1.286";
+export declare const VERSION = "0.1.287";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.286";
+export const VERSION = "0.1.287";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.286",
+  "version": "0.1.287",
   "description": "The simplest way to build AI-powered apps",
   "keywords": [
     "react",
@@ -177,6 +177,10 @@
       "import": "./esm/cli/main.js",
       "types": "./esm/cli/main.d.ts"
     },
+    "./chat/conversation": {
+      "import": "./esm/src/chat/conversation.js",
+      "types": "./esm/src/chat/conversation.d.ts"
+    },
     "./tsconfig.json": "./tsconfig.json"
   },
   "scripts": {},

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.286",
+  "version": "0.1.287",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "workspace": [
@@ -63,7 +63,8 @@ export default {
     "./embedding": "./src/embedding/index.ts",
     "./extensions": "./src/extensions/index.ts",
     "./extensions/interfaces": "./src/extensions/interfaces/index.ts",
-    "./cli": "./cli/main.ts"
+    "./cli": "./cli/main.ts",
+    "./chat/conversation": "./src/chat/conversation.ts"
   },
   "imports": {
     "veryfront/head": "./src/react/runtime/core.ts",
@@ -273,7 +274,8 @@ export default {
     "unified": "npm:unified@11.0.5",
     "vfile": "npm:vfile@6.0.3",
     "class-variance-authority": "npm:class-variance-authority@0.7.1",
-    "tailwind-merge": "npm:tailwind-merge@3.5.0"
+    "tailwind-merge": "npm:tailwind-merge@3.5.0",
+    "veryfront/chat/conversation": "./src/chat/conversation.ts"
   },
   "compilerOptions": {
     "jsx": "react-jsx",