@302ai/media-studio-core 0.1.0-beta.0

package/dist/format/tool-formatter.js

@@ -0,0 +1,395 @@
+import { isObject } from "es-toolkit/compat";
+import { isString } from "es-toolkit/predicate";
+const ASPECT_RATIO_PATTERN = /aspect_ratio:\s*([^\s,;]+)/i;
+const MODEL_PATTERN = /(?:^|\n)\s*-\s*model:\s*([^\s,;]+)/i;
+const DURATION_PATTERN = /(?:^|\n)\s*-\s*duration:\s*([^\s,;]+)/i;
+const OPERATION_PATTERN = /(?:^|\n)\s*-\s*operation:\s*([^\s,;]+)/i;
+const CREATE_TOOL_META = {
+    image_create: { category: "image", defaultLabel: "Generating image" },
+    video_create: { category: "video", defaultLabel: "Generating video" },
+    tts_create: { category: "speech", defaultLabel: "Synthesizing speech" },
+    sfx_create: { category: "sfx", defaultLabel: "Generating sound effects" },
+    stt_transcribe: { category: "stt", defaultLabel: "Transcribing audio" },
+    three_d_create: { category: "3d", defaultLabel: "Generating 3D model" },
+    song_create: { category: "song", defaultLabel: "Generating song" },
+};
+const MODEL_TOOL_NAMES = new Set([
+    "model_list",
+    "model_params",
+    "models_3d",
+    "stt_models",
+    "tts_providers",
+    "tts_voices",
+    "tts_refresh",
+]);
+function isRecord(value) {
+    return isObject(value);
+}
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return `${str.slice(0, maxLen)}...`;
+}
+function getDisplayFileName(filePath) {
+    if (!filePath)
+        return "";
+    return filePath.split(/[/\\]/).pop() || filePath;
+}
+function extractFromPrompt(prompt, pattern) {
+    if (!isString(prompt))
+        return undefined;
+    const match = pattern.exec(prompt);
+    return match?.[1];
+}
+/**
+ * 1:1 normalization parity with main project's `normalizeMcpToolName`.
+ * Strips `tool-` prefix, lowercases, resolves MCP namespaces (`mcp__server__name`),
+ * and trims trailing `output` suffix.
+ */
+export function normalizeMcpToolName(toolName) {
+    const raw = toolName.startsWith("tool-") ? toolName.slice(5) : toolName;
+    const lower = raw.toLowerCase();
+    const separatorIndex = lower.lastIndexOf("__");
+    let normalized = separatorIndex >= 0 ? lower.slice(separatorIndex + 2) : lower;
+    if (normalized.endsWith("output") && normalized !== "output") {
+        normalized = normalized.slice(0, -6);
+    }
+    return normalized;
+}
+/**
+ * Parses and formats a tool call into a structured milestone and dynamic action label.
+ * Fully aligned 1:1 with the main project's tool renderer hierarchy.
+ */
+export function formatToolMilestone(toolName, args) {
+    const normalized = normalizeMcpToolName(toolName);
+    const input = isRecord(args) ? args : {};
+    // 1. Agent dispatch (Agent / task)
+    if (normalized === "agent" || normalized === "task") {
+        const subagentType = isString(input.subagent_type)
+            ? input.subagent_type
+            : "subagent";
+        const description = isString(input.description) ? input.description : "";
+        const model = isString(input.model)
+            ? input.model
+            : extractFromPrompt(input.prompt, MODEL_PATTERN);
+        const aspectRatio = isString(input.aspect_ratio)
+            ? input.aspect_ratio
+            : extractFromPrompt(input.prompt, ASPECT_RATIO_PATTERN);
+        const duration = isString(input.duration)
+            ? input.duration
+            : extractFromPrompt(input.prompt, DURATION_PATTERN);
+        const operation = isString(input.operation)
+            ? input.operation
+            : extractFromPrompt(input.prompt, OPERATION_PATTERN);
+        const descPart = description ? `: ${description}` : "";
+        const tags = [];
+        if (model)
+            tags.push(`model: ${model}`);
+        if (aspectRatio)
+            tags.push(aspectRatio);
+        if (duration)
+            tags.push(duration);
+        const tagsPart = tags.length > 0 ? ` (${tags.join(", ")})` : "";
+        const opPart = operation ? ` <${operation.toUpperCase()}>` : "";
+        const milestoneLine = `[step] Dispatched ${subagentType}${descPart}${tagsPart}${opPart}`;
+        const actionLabel = model
+            ? `Executing ${subagentType} (${model})...`
+            : `Executing ${subagentType}...`;
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "agent",
+            milestoneLine,
+            actionLabel,
+            details: {
+                subagentType,
+                description: description || undefined,
+                model,
+                aspectRatio,
+                duration,
+                operation,
+            },
+        };
+    }
+    // 2. Multimodal Creation family (image_create, video_create, song_create, etc.)
+    if (normalized in CREATE_TOOL_META) {
+        const meta = CREATE_TOOL_META[normalized];
+        const model = isString(input.model)
+            ? input.model
+            : extractFromPrompt(input.prompt, MODEL_PATTERN);
+        const aspectRatio = isString(input.aspect_ratio)
+            ? input.aspect_ratio
+            : extractFromPrompt(input.prompt, ASPECT_RATIO_PATTERN);
+        const duration = isString(input.duration)
+            ? input.duration
+            : typeof input.duration === "number"
+                ? `${input.duration}s`
+                : isString(input.seconds)
+                    ? `${input.seconds}s`
+                    : extractFromPrompt(input.prompt, DURATION_PATTERN);
+        const resolution = isString(input.resolution)
+            ? input.resolution
+            : isString(input.size)
+                ? input.size
+                : undefined;
+        const voice = isString(input.voice)
+            ? input.voice
+            : isString(input.speaker)
+                ? input.speaker
+                : undefined;
+        let operation = isString(input.operation)
+            ? input.operation
+            : extractFromPrompt(input.prompt, OPERATION_PATTERN);
+        if (!operation) {
+            if (input.image)
+                operation = "i2i";
+            else if (input.video)
+                operation = "v2v";
+        }
+        const specs = [];
+        if (aspectRatio)
+            specs.push(aspectRatio);
+        if (duration)
+            specs.push(duration);
+        if (resolution)
+            specs.push(resolution);
+        if (voice)
+            specs.push(`voice: ${voice}`);
+        const modelPart = model ? ` (model: ${model})` : "";
+        const opPart = operation ? ` <${operation.toUpperCase()}>` : "";
+        const specsPart = specs.length > 0 ? ` [${specs.join(", ")}]` : "";
+        const milestoneLine = `[step] Executing ${normalized}${modelPart}${opPart}${specsPart}`;
+        const actionLabel = model
+            ? `${meta.defaultLabel} (${model})...`
+            : `${meta.defaultLabel}...`;
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "create",
+            milestoneLine,
+            actionLabel,
+            details: {
+                model,
+                aspectRatio,
+                duration,
+                resolution,
+                voice,
+                operation,
+            },
+        };
+    }
+    // 3. Model & Capability Discovery tools
+    if (MODEL_TOOL_NAMES.has(normalized)) {
+        const kind = isString(input.kind) ? input.kind : undefined;
+        const model = isString(input.model) ? input.model : undefined;
+        let milestoneLine = `[step] Querying models (${normalized})...`;
+        let actionLabel = "Querying models...";
+        if (normalized === "model_list") {
+            milestoneLine = kind
+                ? `[step] Querying available models (${kind})...`
+                : "[step] Querying available models...";
+            actionLabel = kind
+                ? `Querying available models (${kind})...`
+                : "Querying available models...";
+        }
+        else if (normalized === "model_params" && model) {
+            milestoneLine = `[step] Querying parameters for model: ${model}...`;
+            actionLabel = `Inspecting model ${model}...`;
+        }
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "model",
+            milestoneLine,
+            actionLabel,
+            details: {
+                model,
+                target: kind,
+            },
+        };
+    }
+    // 4. Search & Fetch tools
+    if (normalized === "web_search") {
+        const query = isString(input.query)
+            ? input.query
+            : isString(input.q)
+                ? input.q
+                : "";
+        const queryPart = query ? `: ${query}` : "";
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "search",
+            milestoneLine: `[step] Searching web${queryPart}`,
+            actionLabel: query
+                ? `Searching web: ${truncate(query, 25)}...`
+                : "Searching web...",
+            details: { query: query || undefined },
+        };
+    }
+    if (normalized === "web_fetch" || normalized === "download_file") {
+        const url = isString(input.url) ? input.url : "";
+        const target = url ? ` ${url}` : "";
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "search",
+            milestoneLine: `[step] ${normalized === "download_file" ? "Downloading file" : "Fetching URL"}${target}`,
+            actionLabel: normalized === "download_file"
+                ? "Downloading file..."
+                : "Fetching web content...",
+            details: { target: url || undefined },
+        };
+    }
+    if (normalized === "document_parse") {
+        const target = isString(input.file_path)
+            ? input.file_path
+            : isString(input.url)
+                ? input.url
+                : "";
+        const display = getDisplayFileName(target);
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "search",
+            milestoneLine: display
+                ? `[step] Parsing document: ${display}`
+                : "[step] Parsing document...",
+            actionLabel: display ? `Parsing ${display}...` : "Parsing document...",
+            details: { target: target || undefined },
+        };
+    }
+    if (normalized === "image_analyze" || normalized === "video_analyze") {
+        const mediaType = normalized === "image_analyze" ? "image" : "video";
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "search",
+            milestoneLine: `[step] Analyzing ${mediaType}...`,
+            actionLabel: `Analyzing ${mediaType}...`,
+            details: {},
+        };
+    }
+    if (normalized === "song_lyrics") {
+        const title = isString(input.title)
+            ? input.title
+            : isString(input.query)
+                ? input.query
+                : "";
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "search",
+            milestoneLine: title
+                ? `[step] Searching lyrics: ${title}`
+                : "[step] Searching song lyrics...",
+            actionLabel: "Searching song lyrics...",
+            details: { query: title || undefined },
+        };
+    }
+    // 5. File & Shell tools
+    if (normalized === "read" ||
+        normalized === "read_file" ||
+        normalized === "view_file") {
+        const path = isString(input.file_path)
+            ? input.file_path
+            : isString(input.path)
+                ? input.path
+                : "";
+        const display = getDisplayFileName(path);
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "file",
+            milestoneLine: display
+                ? `[step] Reading file: ${display}`
+                : "[step] Reading file...",
+            actionLabel: display ? `Reading ${display}...` : "Reading file...",
+            details: { target: path || undefined },
+        };
+    }
+    if (normalized === "write" ||
+        normalized === "write_file" ||
+        normalized === "write_to_file" ||
+        normalized === "create_file") {
+        const path = isString(input.file_path)
+            ? input.file_path
+            : isString(input.path)
+                ? input.path
+                : "";
+        const display = getDisplayFileName(path);
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "file",
+            milestoneLine: display
+                ? `[step] Writing file: ${display}`
+                : "[step] Writing file...",
+            actionLabel: display ? `Writing ${display}...` : "Writing file...",
+            details: { target: path || undefined },
+        };
+    }
+    if (normalized === "edit" ||
+        normalized === "edit_file" ||
+        normalized === "replace_file_content" ||
+        normalized === "multi_replace_file_content") {
+        const path = isString(input.file_path)
+            ? input.file_path
+            : isString(input.path)
+                ? input.path
+                : "";
+        const display = getDisplayFileName(path);
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "file",
+            milestoneLine: display
+                ? `[step] Editing file: ${display}`
+                : "[step] Editing file...",
+            actionLabel: display ? `Editing ${display}...` : "Editing file...",
+            details: { target: path || undefined },
+        };
+    }
+    if (normalized === "bash") {
+        const cmd = isString(input.command) ? input.command : "";
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "bash",
+            milestoneLine: cmd
+                ? `[step] Running bash: ${truncate(cmd, 40)}`
+                : "[step] Running bash command...",
+            actionLabel: "Running bash command...",
+            details: { target: cmd || undefined },
+        };
+    }
+    // 6. Skill tools
+    if (normalized === "skill" || normalized === "skill_created") {
+        const skillName = isString(input.skill_name)
+            ? input.skill_name
+            : isString(input.name)
+                ? input.name
+                : "";
+        return {
+            rawName: toolName,
+            normalizedName: normalized,
+            category: "skill",
+            milestoneLine: skillName
+                ? `[step] Using skill: ${skillName}`
+                : "[step] Using skill...",
+            actionLabel: skillName
+                ? `Executing skill ${skillName}...`
+                : "Executing skill...",
+            details: { target: skillName || undefined },
+        };
+    }
+    // 7. Generic Fallback
+    return {
+        rawName: toolName,
+        normalizedName: normalized,
+        category: "other",
+        milestoneLine: `[step] Calling ${normalized}...`,
+        actionLabel: `Working on ${normalized}...`,
+        details: {},
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @302ai/media-studio-core
+ * Official client SDK and isomorphic core for 302 AI Media Studio.
+ */
+export * from "./client/auth.js";
+export * from "./client/chat.js";
+export * from "./client/client.js";
+export * from "./client/session.js";
+export * from "./client/sessions.js";
+export * from "./client/types.js";
+export * from "./format/tool-formatter.js";
+export * from "./media/media-result.js";
+export * from "./sessions/types.js";
+export * from "./stream/events.js";
+export * from "./stream/stream.js";
+export * from "./transport/errors.js";
+export * from "./transport/types.js";
+export * from "./transport/upstream.js";

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * @302ai/media-studio-core
+ * Official client SDK and isomorphic core for 302 AI Media Studio.
+ */
+// Client Layer
+export * from "./client/auth.js";
+export * from "./client/chat.js";
+export * from "./client/client.js";
+export * from "./client/session.js";
+export * from "./client/sessions.js";
+export * from "./client/types.js";
+// Format & Tool Milestone Layer
+export * from "./format/tool-formatter.js";
+// Media Domain Layer
+export * from "./media/media-result.js";
+// Sessions Layer
+export * from "./sessions/types.js";
+// Streaming & Events Layer
+export * from "./stream/events.js";
+export * from "./stream/stream.js";
+export * from "./transport/errors.js";
+// Transport Layer
+export * from "./transport/types.js";
+export * from "./transport/upstream.js";

package/dist/media/media-result.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const MediaResultSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    operation: z.ZodOptional<z.ZodString>;
+    modelUsed: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    resultUrl: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MediaResult = z.infer<typeof MediaResultSchema>;
+/**
+ * Extracts a structured media result from a tool output string or object. Returns null unless
+ * the output contains media task completion identifiers (`task_id` or `result_url`).
+ */
+export declare function extractMediaResult(output: unknown): MediaResult | null;
+/**
+ * Merges an incoming MediaResult into an existing list of media results,
+ * deduplicating by resultUrl or taskId and enriching missing fields.
+ */
+export declare function addOrMergeMediaResult(assets: MediaResult[], incoming: MediaResult): void;

package/dist/media/media-result.js

@@ -0,0 +1,134 @@
+import { isObject } from "es-toolkit/compat";
+import { isString } from "es-toolkit/predicate";
+import { z } from "zod";
+export const MediaResultSchema = z.object({
+    status: z.string().optional(),
+    domain: z.string().optional(),
+    operation: z.string().optional(),
+    modelUsed: z.string().optional(),
+    taskId: z.string().optional(),
+    resultUrl: z.string().optional(),
+    prompt: z.string().optional(),
+});
+function parseKeyValueLines(output) {
+    const fields = new Map();
+    for (const line of output.split("\n")) {
+        const trimmed = line.trim().replace(/^- /, "").trim();
+        const eq = trimmed.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        let value = trimmed.slice(eq + 1).trim();
+        if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+            value = value.slice(1, -1);
+        }
+        if (key)
+            fields.set(key, value);
+    }
+    return fields;
+}
+function isRecord(value) {
+    return isObject(value);
+}
+/**
+ * Extracts a structured media result from a tool output string or object. Returns null unless
+ * the output contains media task completion identifiers (`task_id` or `result_url`).
+ */
+export function extractMediaResult(output) {
+    if (isRecord(output)) {
+        const target = isRecord(output.data) ? output.data : output;
+        const taskId = isString(target.task_id)
+            ? target.task_id
+            : isString(target.taskId)
+                ? target.taskId
+                : undefined;
+        const resultUrl = isString(target.result_url)
+            ? target.result_url
+            : isString(target.resultUrl)
+                ? target.resultUrl
+                : isString(target.url)
+                    ? target.url
+                    : isString(target.image_path)
+                        ? target.image_path
+                        : undefined;
+        if (!taskId && !resultUrl)
+            return null;
+        const domain = isString(target.domain)
+            ? target.domain
+            : isString(target.type)
+                ? target.type
+                : undefined;
+        return {
+            ...(isString(target.status) ? { status: target.status } : {}),
+            ...(domain ? { domain } : {}),
+            ...(isString(target.operation) ? { operation: target.operation } : {}),
+            ...(isString(target.model_used)
+                ? { modelUsed: target.model_used }
+                : isString(target.modelUsed)
+                    ? { modelUsed: target.modelUsed }
+                    : isString(target.model)
+                        ? { modelUsed: target.model }
+                        : {}),
+            ...(taskId ? { taskId } : {}),
+            ...(resultUrl ? { resultUrl } : {}),
+            ...(isString(target.prompt) ? { prompt: target.prompt } : {}),
+        };
+    }
+    if (!isString(output))
+        return null;
+    const fields = parseKeyValueLines(output);
+    const taskId = fields.get("task_id");
+    const resultUrl = fields.get("result_url") ?? fields.get("image_path");
+    if (!taskId && !resultUrl)
+        return null;
+    const status = fields.get("status");
+    const domain = fields.get("domain");
+    const operation = fields.get("operation");
+    const modelUsed = fields.get("model_used");
+    const prompt = fields.get("prompt");
+    return {
+        ...(status ? { status } : {}),
+        ...(domain ? { domain } : {}),
+        ...(operation ? { operation } : {}),
+        ...(modelUsed ? { modelUsed } : {}),
+        ...(taskId ? { taskId } : {}),
+        ...(resultUrl ? { resultUrl } : {}),
+        ...(prompt ? { prompt } : {}),
+    };
+}
+/**
+ * Merges an incoming MediaResult into an existing list of media results,
+ * deduplicating by resultUrl or taskId and enriching missing fields.
+ */
+export function addOrMergeMediaResult(assets, incoming) {
+    const existing = assets.find((a) => (a.resultUrl &&
+        incoming.resultUrl &&
+        a.resultUrl === incoming.resultUrl) ||
+        (a.taskId && incoming.taskId && a.taskId === incoming.taskId));
+    if (existing) {
+        if (!existing.modelUsed && incoming.modelUsed) {
+            existing.modelUsed = incoming.modelUsed;
+        }
+        if (!existing.taskId && incoming.taskId) {
+            existing.taskId = incoming.taskId;
+        }
+        if (!existing.resultUrl && incoming.resultUrl) {
+            existing.resultUrl = incoming.resultUrl;
+        }
+        if (!existing.domain && incoming.domain) {
+            existing.domain = incoming.domain;
+        }
+        if (!existing.prompt && incoming.prompt) {
+            existing.prompt = incoming.prompt;
+        }
+        if (!existing.status && incoming.status) {
+            existing.status = incoming.status;
+        }
+        if (!existing.operation && incoming.operation) {
+            existing.operation = incoming.operation;
+        }
+    }
+    else {
+        assets.push({ ...incoming });
+    }
+}

package/dist/media.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const MediaResultSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    operation: z.ZodOptional<z.ZodString>;
+    modelUsed: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    resultUrl: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MediaResult = z.infer<typeof MediaResultSchema>;
+/**
+ * Extracts a structured media result from a tool output string. Returns null unless
+ * the output contains media task completion identifiers (`task_id` or `result_url`).
+ */
+export declare function extractMediaResult(output: unknown): MediaResult | null;