gaoding-cli 1.0.0-alpha.10

package/dist/src/features/agent/creative-agent-adapter.js

@@ -0,0 +1,31 @@
+import { buildCreativeRequest, creativeContextId, creativeTurnMessages, normalizeCreativeMessages } from "./creative-protocol.js";
+import { parseCreativeStream } from "./creative-stream.js";
+export function createCreativeAgentAdapter(dependencies) {
+    return {
+        async complete(message, access, signal) {
+            signal.throwIfAborted();
+            const ids = message.contextId === undefined
+                ? {
+                    localThreadId: dependencies.idFactory(),
+                    localMessageId: dependencies.idFactory()
+                }
+                : { localMessageId: dependencies.idFactory() };
+            const stream = await dependencies.transport.postStream({
+                path: "/ai-agent/v1/thread/completion",
+                body: buildCreativeRequest(message, ids),
+                accept: "text/event-stream",
+                credential: access.credential,
+                organizationId: access.organizationId,
+                signal
+            });
+            const contextId = creativeContextId(await parseCreativeStream(stream, signal));
+            const messages = await dependencies.transport.getJson({
+                path: `/ai-agent/v1/thread/${encodeURIComponent(contextId)}/messages`,
+                credential: access.credential,
+                organizationId: access.organizationId,
+                signal
+            });
+            return normalizeCreativeMessages(creativeTurnMessages(messages, ids.localMessageId));
+        }
+    };
+}

package/dist/src/features/agent/creative-protocol.js

@@ -0,0 +1,324 @@
+import { RemoteRequestError } from "../../platform/signed-http-transport.js";
+export function buildCreativeRequest(message, ids) {
+    const prompt = [];
+    const textParts = [];
+    const attachments = [];
+    const parameters = {};
+    const answerValues = [];
+    const answeredQuestions = [];
+    let questionMessageId;
+    let hasAnswers = false;
+    for (const part of message.parts) {
+        if (part.kind === "text") {
+            textParts.push(part.text);
+            prompt.push({ type: "text", content: part.text });
+            continue;
+        }
+        if (part.kind === "asset") {
+            if (part.role === "first_frame" || part.role === "last_frame") {
+                prompt.push({
+                    type: "text",
+                    content: part.role === "first_frame" ? "首帧" : "尾帧"
+                });
+            }
+            prompt.push({
+                type: "media",
+                url: part.asset.url,
+                name: part.asset.filename,
+                mime: part.asset.mediaType
+            });
+            attachments.push({
+                uri: part.asset.url,
+                mime_type: part.asset.mediaType,
+                from_user_upload: part.asset.fromUserUpload
+            });
+            continue;
+        }
+        if (part.kind === "parameters") {
+            if (part.data.ratio !== undefined)
+                parameters.ratio = part.data.ratio;
+            if (part.data.resolution !== undefined)
+                parameters.resolution = part.data.resolution;
+            if (part.data.durationSeconds !== undefined) {
+                parameters.duration = String(part.data.durationSeconds);
+            }
+            continue;
+        }
+        hasAnswers = true;
+        questionMessageId ??= part.data.questionMessageId;
+        for (const answer of part.data.answers) {
+            const values = [...answer.values];
+            answerValues.push(values);
+            answeredQuestions.push({ question: answer.question, answers: values });
+        }
+    }
+    const hasParameters = Object.keys(parameters).length > 0;
+    let content;
+    if (hasAnswers) {
+        content = {
+            type: "user",
+            text: textParts.join("\n"),
+            prompt: prompt.length > 0 ? prompt : [{ type: "text", content: "" }],
+            ...(hasParameters ? { parameters } : {}),
+            answer: { answers: answerValues }
+        };
+    }
+    else if (prompt.length === 1 && prompt[0]?.type === "text" && !hasParameters) {
+        content = { type: "plain", text: prompt[0].content };
+    }
+    else {
+        content = {
+            type: "plain",
+            prompt,
+            ...(hasParameters ? { parameters } : {})
+        };
+    }
+    const extra = {};
+    if (hasAnswers && questionMessageId !== undefined) {
+        extra.lastToolMessageId = questionMessageId;
+        extra.last_tool_message_id = questionMessageId;
+        extra.askUserQuestionAnsweredQuestions = answeredQuestions;
+        extra.questions = answeredQuestions;
+    }
+    return {
+        content,
+        name: hasAnswers ? "ask_user_question" : "user",
+        role: "user",
+        local_thread_id: message.contextId === undefined ? ids.localThreadId ?? "" : "",
+        local_message_id: ids.localMessageId,
+        thread_id: message.contextId ?? "",
+        attachments,
+        extra
+    };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function fail() {
+    throw new RemoteRequestError();
+}
+export function creativeContextId(messages) {
+    if (messages.some((message) => message.event === "system_error"))
+        return fail();
+    const contextId = messages
+        .map((message) => nonEmptyString(message.thread_id))
+        .find((value) => value !== undefined);
+    return contextId ?? fail();
+}
+export function creativeTurnMessages(value, localMessageId) {
+    if (!Array.isArray(value) || !value.every((message) => record(message) !== undefined)) {
+        return fail();
+    }
+    const messages = value;
+    const start = messages.findIndex((message) => message.role === "user" && message.local_message_id === localMessageId);
+    if (start < 0)
+        return fail();
+    return messages.slice(start);
+}
+function contentOf(message) {
+    return record(message.content);
+}
+function functionPayload(message) {
+    const content = contentOf(message);
+    if (content?.type !== "function_call")
+        return undefined;
+    return record(parseJson(content.text));
+}
+function isQuestionCall(message) {
+    return functionPayload(message)?.name === "ask_user_question";
+}
+function hasHiddenTransportRole(message) {
+    return message.role === "user" || message.role === "system" || message.role === "tool";
+}
+function inferMediaType(url) {
+    let pathname;
+    try {
+        pathname = new URL(url).pathname;
+    }
+    catch {
+        pathname = url.split(/[?#]/, 1)[0] ?? "";
+    }
+    const extension = pathname.split(".").at(-1)?.toLowerCase();
+    return {
+        gif: "image/gif",
+        jpeg: "image/jpeg",
+        jpg: "image/jpeg",
+        mov: "video/quicktime",
+        mp3: "audio/mpeg",
+        mp4: "video/mp4",
+        png: "image/png",
+        wav: "audio/wav",
+        webm: "video/webm",
+        webp: "image/webp"
+    }[extension ?? ""] ?? "application/octet-stream";
+}
+function functionResponseParts(raw) {
+    const parsed = parseJson(raw);
+    const values = Array.isArray(parsed) ? parsed : parsed === undefined ? [] : [parsed];
+    const parts = [];
+    for (const value of values) {
+        const item = record(value);
+        if (item === undefined)
+            continue;
+        const text = nonEmptyString(item.text);
+        if (text !== undefined)
+            parts.push({ text });
+        const url = nonEmptyString(item.uri ?? item.url);
+        if (url === undefined)
+            continue;
+        const mediaType = nonEmptyString(item.mime_type ?? item.mimeType) ?? inferMediaType(url);
+        const filename = nonEmptyString(item.filename ?? item.name);
+        parts.push({
+            url,
+            mediaType,
+            ...(filename === undefined ? {} : { filename })
+        });
+    }
+    return parts;
+}
+function parseQuestionPart(message) {
+    const payload = functionPayload(message);
+    if (payload?.name !== "ask_user_question")
+        return fail();
+    const argumentsValue = parseJson(payload.arguments);
+    const argumentsRecord = record(argumentsValue);
+    if (argumentsRecord === undefined || !Array.isArray(argumentsRecord.questions)
+        || argumentsRecord.questions.length === 0)
+        return fail();
+    const questions = argumentsRecord.questions.map((value) => {
+        const question = record(value);
+        const text = nonEmptyString(question?.question);
+        if (question === undefined || text === undefined)
+            return fail();
+        const rawOptions = question.options ?? [];
+        if (!Array.isArray(rawOptions))
+            return fail();
+        const options = rawOptions.map((rawOption) => {
+            const option = record(rawOption);
+            const label = nonEmptyString(option?.label);
+            if (option === undefined || label === undefined)
+                return fail();
+            return { label };
+        });
+        const allowMultiple = question.allow_multiple ?? question.allowMultiple;
+        if (typeof allowMultiple !== "boolean")
+            return fail();
+        return { question: text, options, allowMultiple };
+    });
+    const title = nonEmptyString(argumentsRecord.title);
+    return {
+        data: {
+            ...(title === undefined ? {} : { title }),
+            questions: [questions[0], ...questions.slice(1)]
+        }
+    };
+}
+function dedupeParts(parts) {
+    const texts = new Set();
+    const urls = new Set();
+    return parts.filter((part) => {
+        if ("text" in part) {
+            if (texts.has(part.text))
+                return false;
+            texts.add(part.text);
+            return true;
+        }
+        if ("url" in part) {
+            if (urls.has(part.url))
+                return false;
+            urls.add(part.url);
+        }
+        return true;
+    });
+}
+export function normalizeCreativeMessages(messages) {
+    const contextId = creativeContextId(messages);
+    const latest = new Map();
+    const anonymous = [];
+    for (const message of messages) {
+        const id = nonEmptyString(message.message_id);
+        if (id === undefined)
+            anonymous.push(message);
+        else
+            latest.set(id, message);
+    }
+    const normalized = [...latest.values(), ...anonymous];
+    const parts = [];
+    for (const message of normalized) {
+        if (hasHiddenTransportRole(message))
+            continue;
+        const content = contentOf(message);
+        if (content !== undefined) {
+            if (content.type === "plain" || content.type === "user" || content.type === "text") {
+                const text = nonEmptyString(content.text);
+                if (text !== undefined)
+                    parts.push({ text });
+            }
+            else if (content.type === "function_response") {
+                parts.push(...functionResponseParts(content.text));
+            }
+        }
+        else {
+            const text = nonEmptyString(message.content);
+            if (text !== undefined)
+                parts.push({ text });
+        }
+    }
+    const question = normalized.find((message) => !hasHiddenTransportRole(message) && isQuestionCall(message));
+    let questionMessageId;
+    if (question !== undefined) {
+        questionMessageId = nonEmptyString(question.message_id);
+        if (questionMessageId === undefined)
+            return fail();
+        parts.push(parseQuestionPart(question));
+    }
+    const publicParts = dedupeParts(parts);
+    if (publicParts.length === 0)
+        return fail();
+    const usageItems = [];
+    for (const message of normalized) {
+        if (contentOf(message)?.type !== "function_response")
+            continue;
+        const extra = record(message.extra);
+        const amount = extra?.deduct_points;
+        if (amount === undefined)
+            continue;
+        if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
+            return fail();
+        if (amount === 0)
+            continue;
+        const model = nonEmptyString(extra?.scene_code);
+        if (model === undefined)
+            return fail();
+        usageItems.push({ model, cost: { unit: "gaodou", amount } });
+    }
+    return {
+        message: {
+            ...(questionMessageId === undefined ? {} : { messageId: questionMessageId }),
+            contextId,
+            parts: [publicParts[0], ...publicParts.slice(1)]
+        },
+        usage: {
+            cost: {
+                unit: "gaodou",
+                amount: usageItems.reduce((total, item) => total + item.cost.amount, 0)
+            },
+            items: usageItems
+        }
+    };
+}

package/dist/src/features/agent/creative-stream.js

@@ -0,0 +1,127 @@
+function isMessage(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function extractPayloads(raw) {
+    const lines = raw.replace(/\r\n?/g, "\n").split("\n");
+    const payloads = [];
+    let dataLines = [];
+    let foundData = false;
+    const flush = () => {
+        if (dataLines.length > 0)
+            payloads.push(dataLines.join("\n"));
+        dataLines = [];
+    };
+    for (const line of lines) {
+        if (line.startsWith("data:")) {
+            foundData = true;
+            dataLines.push(line.slice(5).replace(/^ /, ""));
+        }
+        else if (line === "") {
+            flush();
+        }
+        else if (line.startsWith(":") || line.startsWith("event:") || line.startsWith("id:")) {
+            continue;
+        }
+        else if (!foundData || dataLines.length > 0) {
+            dataLines.push(line);
+        }
+    }
+    flush();
+    return payloads;
+}
+function jsonEnd(value, start) {
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < value.length; index += 1) {
+        const character = value[index];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === '"')
+                inString = false;
+            continue;
+        }
+        if (character === '"') {
+            inString = true;
+            continue;
+        }
+        if (character === "{" || character === "[")
+            stack.push(character);
+        else if (character === "}" || character === "]") {
+            const opening = stack.pop();
+            if ((character === "}" && opening !== "{") || (character === "]" && opening !== "[")) {
+                return -1;
+            }
+            if (stack.length === 0)
+                return index;
+        }
+    }
+    return -1;
+}
+function parseSequence(payload) {
+    if (payload.trim() === "[DONE]")
+        return [];
+    const values = [];
+    let index = 0;
+    while (index < payload.length) {
+        const objectStart = payload.indexOf("{", index);
+        const arrayStart = payload.indexOf("[", index);
+        const starts = [objectStart, arrayStart].filter((value) => value >= 0);
+        if (starts.length === 0)
+            break;
+        const start = Math.min(...starts);
+        const end = jsonEnd(payload, start);
+        if (end < 0)
+            break;
+        try {
+            values.push(JSON.parse(payload.slice(start, end + 1)));
+        }
+        catch {
+            // Ignore only the malformed value; a later complete value can still be read.
+        }
+        index = end + 1;
+    }
+    return values;
+}
+export async function parseCreativeStream(stream, signal) {
+    signal.throwIfAborted();
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let raw = "";
+    const onAbort = () => {
+        void reader.cancel(signal.reason).catch(() => undefined);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    try {
+        while (true) {
+            signal.throwIfAborted();
+            const result = await reader.read();
+            signal.throwIfAborted();
+            if (result.done)
+                break;
+            raw += decoder.decode(result.value, { stream: true });
+        }
+        raw += decoder.decode();
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+        reader.releaseLock();
+    }
+    const messages = [];
+    for (const payload of extractPayloads(raw)) {
+        for (const value of parseSequence(payload)) {
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    if (isMessage(item))
+                        messages.push(item);
+            }
+            else if (isMessage(value)) {
+                messages.push(value);
+            }
+        }
+    }
+    return messages;
+}

package/dist/src/features/agent/use-cases.js

@@ -0,0 +1,113 @@
+import { parseSafeRemoteAssetUrl, UrlSafetyError } from "../../platform/url-safety.js";
+export class AgentInputError extends Error {
+    constructor() {
+        super("Agent 输入不可用。");
+        this.name = "AgentInputError";
+    }
+}
+const mediaTypes = {
+    avif: "image/avif",
+    gif: "image/gif",
+    heic: "image/heic",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    mp4: "video/mp4",
+    png: "image/png",
+    webp: "image/webp"
+};
+function pathnameFilename(url) {
+    const segment = url.pathname.split("/").filter(Boolean).at(-1);
+    if (segment === undefined)
+        return "creative-media";
+    try {
+        return decodeURIComponent(segment) || "creative-media";
+    }
+    catch {
+        return segment;
+    }
+}
+function inferMediaType(filename) {
+    const extension = filename.split(".").at(-1)?.toLowerCase();
+    return extension === undefined || extension === filename.toLowerCase()
+        ? "application/octet-stream"
+        : mediaTypes[extension] ?? "application/octet-stream";
+}
+export function createAgentUseCases(dependencies) {
+    return {
+        async send({ input, access, signal }) {
+            signal.throwIfAborted();
+            const prepared = [];
+            for (const part of input.message.parts) {
+                signal.throwIfAborted();
+                if ("text" in part) {
+                    prepared.push({ kind: "text", text: part.text });
+                    continue;
+                }
+                if ("url" in part) {
+                    const role = part.metadata?.role ?? "reference";
+                    if (part.url.startsWith("file:")) {
+                        const uploadInput = {
+                            url: part.url,
+                            ...(part.mediaType === undefined ? {} : { mediaType: part.mediaType }),
+                            ...(part.filename === undefined ? {} : { filename: part.filename })
+                        };
+                        const asset = await dependencies.uploader.upload(uploadInput, access, signal);
+                        prepared.push({ kind: "asset", asset, role });
+                        continue;
+                    }
+                    let url;
+                    try {
+                        url = parseSafeRemoteAssetUrl(part.url);
+                    }
+                    catch (error) {
+                        if (error instanceof UrlSafetyError)
+                            throw new AgentInputError();
+                        throw error;
+                    }
+                    const filename = part.filename ?? pathnameFilename(url);
+                    prepared.push({
+                        kind: "asset",
+                        asset: {
+                            url: part.url,
+                            mediaType: part.mediaType ?? inferMediaType(filename),
+                            filename,
+                            fromUserUpload: false
+                        },
+                        role
+                    });
+                    continue;
+                }
+                if ("questionMessageId" in part.data) {
+                    prepared.push({
+                        kind: "answers",
+                        data: {
+                            questionMessageId: part.data.questionMessageId,
+                            answers: part.data.answers.map((answer) => ({
+                                question: answer.question,
+                                values: [...answer.values]
+                            }))
+                        }
+                    });
+                    continue;
+                }
+                prepared.push({
+                    kind: "parameters",
+                    data: {
+                        ...(part.data.ratio === undefined ? {} : { ratio: part.data.ratio }),
+                        ...(part.data.resolution === undefined ? {} : { resolution: part.data.resolution }),
+                        ...(part.data.durationSeconds === undefined
+                            ? {}
+                            : { durationSeconds: part.data.durationSeconds })
+                    }
+                });
+            }
+            signal.throwIfAborted();
+            return dependencies.completion.complete({
+                ...(input.message.contextId === undefined
+                    ? {}
+                    : { contextId: input.message.contextId }),
+                parts: prepared
+            }, access, signal);
+        }
+    };
+}

package/dist/src/features/auth/access-policy.js

@@ -0,0 +1,101 @@
+import { OrganizationInvalidError } from "../org/use-cases.js";
+export class AuthRequiredError extends Error {
+    constructor() {
+        super("请先执行 gd-cli auth login");
+        this.name = "AuthRequiredError";
+    }
+}
+export class AuthExpiredError extends Error {
+    constructor() {
+        super("登录已过期，请退出后重新登录。");
+        this.name = "AuthExpiredError";
+    }
+}
+const REFRESH_WINDOW_MS = 5 * 60 * 1000;
+const organizationRefreshes = new Map();
+export function createAccessPolicies(dependencies) {
+    async function readValidState(signal) {
+        signal.throwIfAborted();
+        const state = await dependencies.store.read();
+        signal.throwIfAborted();
+        if (!state)
+            throw new AuthRequiredError();
+        if (Date.parse(state.credential.expiresAt) <= dependencies.now().getTime()) {
+            throw new AuthExpiredError();
+        }
+        return state;
+    }
+    async function refreshOrganization(state, signal) {
+        const key = `${state.credential.accessKey}\0${state.organization.id}`;
+        let refresh = organizationRefreshes.get(key);
+        if (!refresh) {
+            refresh = (async () => {
+                let organization;
+                try {
+                    organization = await dependencies.refreshCurrentOrganization({ state, signal });
+                }
+                catch (error) {
+                    if (error instanceof OrganizationInvalidError) {
+                        const latest = await dependencies.store.read();
+                        if (sameOrganization(latest, state)) {
+                            const { organization: _organization, ...withoutOrganization } = latest;
+                            await dependencies.store.write(withoutOrganization);
+                        }
+                    }
+                    throw error;
+                }
+                const latest = await dependencies.store.read();
+                if (sameOrganization(latest, state)) {
+                    await dependencies.store.write({ ...latest, organization });
+                }
+            })();
+            organizationRefreshes.set(key, refresh);
+        }
+        try {
+            await refresh;
+        }
+        finally {
+            if (organizationRefreshes.get(key) === refresh)
+                organizationRefreshes.delete(key);
+        }
+    }
+    return {
+        none: {
+            async authorize(signal) {
+                signal.throwIfAborted();
+                return { policy: "none" };
+            }
+        },
+        credential: {
+            async authorize(signal) {
+                const state = await readValidState(signal);
+                return { policy: "credential", state };
+            }
+        },
+        organization: {
+            async authorize(signal) {
+                let state = await readValidState(signal);
+                if (!state.organization)
+                    throw new OrganizationInvalidError();
+                if (bindingNeedsRefresh(state.organization, dependencies.now())) {
+                    await refreshOrganization(state, signal);
+                    state = await readValidState(signal);
+                    if (!state.organization)
+                        throw new OrganizationInvalidError();
+                }
+                return {
+                    policy: "organization",
+                    state: state
+                };
+            }
+        }
+    };
+}
+function bindingNeedsRefresh(organization, now) {
+    return organization.bindExpiresAt === undefined
+        || Date.parse(organization.bindExpiresAt) <= now.getTime() + REFRESH_WINDOW_MS;
+}
+function sameOrganization(current, expected) {
+    return current?.credential.accessKey === expected.credential.accessKey
+        && current.organization?.id === expected.organization.id;
+}