npm - @pasko70/pibo - Versions diffs - 1.4.3 → 1.4.5 - Mend

@pasko70/pibo 1.4.3 → 1.4.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-C3GTPyDo.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-CRUSv6iR.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-B5QK07zO.css">
 	</head>
 	<body>

package/dist/apps/vscode-artifacts/latest.vsix CHANGED Viewed

Binary file

package/dist/apps/vscode-artifacts/{pibo-vscode-ext-1.4.2.vsix → pibo-vscode-ext-1.4.5.vsix} RENAMED Viewed

Binary file

package/dist/plugins/codex-compat.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createCodexImageGenerationToolProfile } from "../tools/codex-image-generation.js";
 import { definePiboPlugin } from "./registry.js";
 const CODEX_COMPAT_REGISTERED_TOOL_NAMES = [
     "apply_patch",
@@ -22,6 +23,7 @@ export const piboCodexCompatPlugin = definePiboPlugin({
                 description: toolDescriptions[name],
             });
         }
+        api.registerTool(createCodexImageGenerationToolProfile());
         api.registerContextFile({
             key: CODEX_BASE_PROMPT_CONTEXT_FILE_KEY,
             label: "Codex Base Prompt",

package/dist/providers/glm.js CHANGED Viewed

@@ -7,7 +7,7 @@ export const GLM_5_2_MODEL = {
     id: "GLM-5.2",
     name: "GLM 5.2",
     reasoning: false,
-    contextWindow: 200000,
+    contextWindow: 1_000_000,
     maxTokens: 8192,
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
     input: ["text"],

package/dist/session-ui/terminalRows.js CHANGED Viewed

@@ -128,7 +128,7 @@ function createToolRowCandidate(node, turnId) {
     const image = classifyImageTool(node);
     if (image) {
         const row = createImageToolRow(node, image);
-        return { row, turnId, image: image.detail };
+        return { row, turnId, image: image.groupable ? image.detail : undefined };
     }
     const preview = previewLines(node.error ?? node.output, COMPACT_TERMINAL_OUTPUT_PREVIEW_LINES, node.error ? "red" : "dim");
     const row = {
@@ -159,7 +159,7 @@ function createToolRowCandidate(node, turnId) {
 }
 function createImageToolRow(node, image) {
     const status = mapStatus(node.status);
-    const detailLabel = image.path ? `Path: ${image.path}` : image.query ? `Query: ${image.query}` : image.mimeType ? `Type: ${image.mimeType}` : "Image content returned";
+    const detailLabel = image.path ? `Path: ${image.path}` : image.artifactId ? `Artifact: ${image.artifactId}` : image.query ? `Query: ${image.query}` : image.mimeType ? `Type: ${image.mimeType}` : "Image content returned";
     return {
         id: node.id,
         kind: "tool.image",
@@ -168,7 +168,7 @@ function createImageToolRow(node, image) {
         lines: [
             {
                 prefix: "bullet",
-                tokens: [token(imageToolVerb(node.status, image.count), toneForStatus(node.status), "semibold")],
+                tokens: [token(image.verb, toneForStatus(node.status), "semibold")],
             },
             {
                 prefix: "detail",
@@ -186,7 +186,7 @@ function createToolResultRowCandidate(node, turnId) {
     const image = classifyImageTool(node);
     if (image) {
         const row = createImageToolRow(node, image);
-        return { row, turnId, image: image.detail };
+        return { row, turnId, image: image.groupable ? image.detail : undefined };
     }
     return { row: createToolResultRow(node), turnId };
 }
@@ -640,32 +640,48 @@ function detailItemsForGroup(candidates, kind) {
 function classifyImageTool(node) {
     const normalized = (node.title ?? "").trim().toLowerCase();
     const args = isRecord(node.input) ? node.input : undefined;
-    const path = previewPath(args) ?? previewPath(isRecord(node.output) ? recordField(node.output, "details") : undefined) ?? previewPath(isRecord(node.output) ? node.output : undefined);
+    const output = isRecord(node.output) ? node.output : undefined;
+    const details = recordField(output, "details");
+    const codexOperation = normalized === "codex_image_generation" ? codexImageOperation(details) ?? codexImageOperationFromInput(args) : undefined;
+    const path = codexOperation
+        ? stringValue(details?.savedPath) ?? previewPath(details)
+        : previewPath(args) ?? previewPath(details) ?? previewPath(output);
+    const artifactId = codexOperation ? stringValue(details?.artifactId) : undefined;
     const query = previewQuery(args);
     const images = collectImagePayloads(node.output);
     const isImageTool = matchesTool(normalized, ["view_image", "image", "screenshot"]);
-    if (!images.length && !isImageTool)
+    if (!images.length && !isImageTool && !codexOperation)
         return undefined;
     const mimeType = images.map((image) => image.mimeType).find((value) => Boolean(value));
     const count = Math.max(1, images.length);
     const summary = {
         type: images.length > 1 ? "images" : images.length === 1 ? "image" : "image_reference",
+        toolName: codexOperation ? node.title : undefined,
+        operation: codexOperation,
         path,
+        savedPath: codexOperation ? path : undefined,
+        artifactId,
+        model: codexOperation ? stringValue(details?.model) : undefined,
+        referencedImageCount: codexOperation ? numberValue(details?.referencedImageCount) : undefined,
         query,
         mimeType,
         count: count > 1 ? count : undefined,
         detail: images.length ? "Image data hidden in terminal view." : "Image path only; binary data is hidden in terminal view.",
     };
-    const labelTarget = path ?? query ?? mimeType ?? "image";
+    const labelTarget = path ?? artifactId ?? query ?? mimeType ?? "image";
+    const verb = codexOperation ? codexImageVerb(node.status, codexOperation) : imageToolVerb(node.status, count);
     return {
         count,
         path,
+        artifactId,
         query,
         mimeType,
+        verb,
+        groupable: !codexOperation,
         summary,
         detail: {
             id: node.id,
-            label: `${node.status === "error" ? "Image failed" : "Viewed image"} ${labelTarget}`,
+            label: `${verb} ${labelTarget}`,
             status: mapStatus(node.status),
             input: sanitizeImagePayload(node.input),
             output: summary,
@@ -725,6 +741,34 @@ function imageToolVerb(status, count) {
         return count > 1 ? "Image reads failed" : "Image read failed";
     return count > 1 ? "Viewed images" : "Viewed image";
 }
+function codexImageOperation(details) {
+    const operation = stringValue(details?.operation);
+    return operation === "generate" || operation === "edit" ? operation : undefined;
+}
+function codexImageOperationFromInput(args) {
+    if (!args)
+        return undefined;
+    const referencedPaths = args.referenced_image_paths;
+    if (Array.isArray(referencedPaths) && referencedPaths.length > 0)
+        return "edit";
+    if (numberValue(args.num_last_images_to_include) !== undefined)
+        return "edit";
+    return "generate";
+}
+function codexImageVerb(status, operation) {
+    if (operation === "edit") {
+        if (status === "running")
+            return "Editing image";
+        if (status === "error")
+            return "Image edit failed";
+        return "Edited image";
+    }
+    if (status === "running")
+        return "Generating image";
+    if (status === "error")
+        return "Image generation failed";
+    return "Generated image";
+}
 function recordField(record, key) {
     const value = record?.[key];
     return isRecord(value) ? value : undefined;
@@ -789,6 +833,9 @@ function previewQuery(value) {
     }
     return undefined;
 }
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
 function previewLines(value, maxVisibleLines, tone = "dim", _maxLineLength = 160) {
     const empty = { lines: [], visibleLineCount: 0, omittedLineCount: 0, totalLineCount: 0, maxVisibleLineCount: maxVisibleLines };
     const text = previewText(value);

package/dist/tools/codex-image-generation.js ADDED Viewed

@@ -0,0 +1,272 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { platform, release, arch } from "node:os";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
+import { Type } from "@mariozechner/pi-ai";
+import { defineTool } from "@mariozechner/pi-coding-agent";
+import { getPiboHome } from "../core/pibo-home.js";
+const OPENAI_CODEX_PROVIDER = "openai-codex";
+const DEFAULT_CODEX_BACKEND_BASE_URL = "https://chatgpt.com/backend-api";
+const CODEX_IMAGE_MODEL = "gpt-image-2";
+const MAX_EDIT_IMAGES = 5;
+const OPENAI_JWT_CLAIM_PATH = "https://api.openai.com/auth";
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+export function resolveCodexImageUrl(operation, baseUrl) {
+    const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BACKEND_BASE_URL;
+    let normalized = trimTrailingSlashes(raw.trim());
+    if (normalized.endsWith("/codex/responses"))
+        normalized = normalized.slice(0, -"/responses".length);
+    if (!normalized.endsWith("/codex"))
+        normalized = `${normalized}/codex`;
+    return `${normalized}/images/${operation}`;
+}
+function decodeJwtPayload(token) {
+    try {
+        const payload = token.split(".")[1];
+        if (!payload)
+            return undefined;
+        const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+        const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+        const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getOpenAiAccountId(accessToken, storedAccountId) {
+    if (typeof storedAccountId === "string" && storedAccountId.trim().length > 0)
+        return storedAccountId;
+    const payload = decodeJwtPayload(accessToken);
+    const auth = payload?.[OPENAI_JWT_CLAIM_PATH];
+    if (!auth || typeof auth !== "object" || Array.isArray(auth))
+        return undefined;
+    const accountId = auth.chatgpt_account_id;
+    return typeof accountId === "string" && accountId.trim().length > 0 ? accountId : undefined;
+}
+async function getCodexImageAuth() {
+    const authStorage = AuthStorage.create();
+    const credential = authStorage.get(OPENAI_CODEX_PROVIDER);
+    if (credential?.type !== "oauth") {
+        throw new Error("codex_image_generation requires ChatGPT/Codex OAuth login for provider openai-codex. Use the existing OpenAI Codex login flow; API keys are not supported for this tool.");
+    }
+    const accessToken = await authStorage.getApiKey(OPENAI_CODEX_PROVIDER, { includeFallback: false });
+    if (!accessToken) {
+        throw new Error("codex_image_generation could not load a ChatGPT/Codex OAuth access token for provider openai-codex. Please log in again with the OpenAI Codex login flow.");
+    }
+    const accountId = getOpenAiAccountId(accessToken, credential.accountId);
+    if (!accountId) {
+        throw new Error("codex_image_generation could not resolve the ChatGPT account id from the openai-codex OAuth credential. Please log in again with the OpenAI Codex login flow.");
+    }
+    return { accessToken, accountId };
+}
+function mimeTypeForPath(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        case ".gif":
+            return "image/gif";
+        default:
+            return "image/png";
+    }
+}
+function resolveCwd(baseCwd, path) {
+    return isAbsolute(path) ? path : resolve(baseCwd, path);
+}
+function isImageContent(value) {
+    return Boolean(value)
+        && typeof value === "object"
+        && value.type === "image"
+        && typeof value.data === "string"
+        && typeof value.mimeType === "string";
+}
+function imageContentToDataUrl(image) {
+    if (image.data.startsWith("data:"))
+        return image.data;
+    return `data:${image.mimeType};base64,${image.data}`;
+}
+async function imageFileToDataUrl(cwd, path) {
+    const resolved = resolveCwd(cwd, path);
+    const data = await readFile(resolved);
+    return `data:${mimeTypeForPath(resolved)};base64,${data.toString("base64")}`;
+}
+function contentFromSessionEntry(entry) {
+    if (!entry || typeof entry !== "object")
+        return undefined;
+    const record = entry;
+    if (record.type === "message") {
+        const message = record.message;
+        return message && typeof message === "object" ? message.content : undefined;
+    }
+    if (record.type === "custom_message")
+        return record.content;
+    return undefined;
+}
+function recentImagesFromSessionEntries(entries, count) {
+    const images = [];
+    for (const entry of [...entries].reverse()) {
+        const content = contentFromSessionEntry(entry);
+        if (!Array.isArray(content))
+            continue;
+        for (const item of [...content].reverse()) {
+            if (!isImageContent(item))
+                continue;
+            images.push(imageContentToDataUrl(item));
+            if (images.length === count)
+                break;
+        }
+        if (images.length === count)
+            break;
+    }
+    images.reverse();
+    return images.map((image_url) => ({ image_url }));
+}
+function validateImageArgs(params) {
+    if (params.prompt.trim().length === 0)
+        throw new Error("`prompt` must not be empty.");
+    const pathCount = params.referenced_image_paths?.length ?? 0;
+    if (pathCount > MAX_EDIT_IMAGES)
+        throw new Error(`\`referenced_image_paths\` must contain at most ${MAX_EDIT_IMAGES} paths.`);
+    if (pathCount > 0 && params.num_last_images_to_include !== undefined) {
+        throw new Error("Provide only one of `referenced_image_paths` or `num_last_images_to_include`.");
+    }
+    if (params.num_last_images_to_include !== undefined) {
+        if (!Number.isInteger(params.num_last_images_to_include) || params.num_last_images_to_include < 1 || params.num_last_images_to_include > MAX_EDIT_IMAGES) {
+            throw new Error(`\`num_last_images_to_include\` must be an integer between 1 and ${MAX_EDIT_IMAGES}.`);
+        }
+    }
+}
+function sanitizePathPart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 120) || "unknown";
+}
+function artifactPath(sessionId, toolCallId) {
+    const safeSessionId = sanitizePathPart(sessionId?.trim() || "local");
+    const safeToolCallId = sanitizePathPart(toolCallId || `image_${Date.now()}`);
+    const artifactId = `${safeSessionId}/${safeToolCallId}.png`;
+    return {
+        artifactId,
+        savedPath: join(getPiboHome(), "generated_images", safeSessionId, `${safeToolCallId}.png`),
+    };
+}
+async function saveGeneratedImage(sessionId, toolCallId, b64Json) {
+    const target = artifactPath(sessionId, toolCallId);
+    await mkdir(dirname(target.savedPath), { recursive: true });
+    await writeFile(target.savedPath, Buffer.from(b64Json.trim(), "base64"));
+    return target;
+}
+function truncateErrorBody(text) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > 1000 ? `${compact.slice(0, 1000)}…` : compact;
+}
+async function postCodexImageRequest(operation, body, auth, signal, baseUrl) {
+    const url = resolveCodexImageUrl(operation, baseUrl);
+    const response = await fetch(url, {
+        method: "POST",
+        signal,
+        headers: {
+            Authorization: `Bearer ${auth.accessToken}`,
+            "chatgpt-account-id": auth.accountId,
+            originator: "pi",
+            "User-Agent": `pibo (${platform()} ${release()}; ${arch()})`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        throw new Error(`Codex image ${operation} request failed: ${response.status}${text ? ` ${truncateErrorBody(text)}` : ""}`);
+    }
+    return await response.json();
+}
+function firstImageB64(response) {
+    const b64 = response.data?.[0]?.b64_json;
+    if (!b64 || typeof b64 !== "string")
+        throw new Error("Codex image generation returned no image data.");
+    return b64;
+}
+function createRequest(prompt, images) {
+    return {
+        ...(images && images.length > 0 ? { images } : {}),
+        prompt,
+        background: "auto",
+        model: CODEX_IMAGE_MODEL,
+        quality: "auto",
+        size: "auto",
+    };
+}
+async function collectEditImages(params, cwd, sessionEntries) {
+    const paths = params.referenced_image_paths ?? [];
+    if (paths.length > 0) {
+        return await Promise.all(paths.map(async (path) => ({ image_url: await imageFileToDataUrl(cwd, path) })));
+    }
+    if (params.num_last_images_to_include !== undefined) {
+        const images = recentImagesFromSessionEntries(sessionEntries, params.num_last_images_to_include);
+        if (images.length !== params.num_last_images_to_include) {
+            throw new Error(`Requested the last ${params.num_last_images_to_include} conversation images, but only ${images.length} were available.`);
+        }
+        return images;
+    }
+    return [];
+}
+export function createCodexImageGenerationToolDefinition(context = {}, options = {}) {
+    return defineTool({
+        name: "codex_image_generation",
+        label: "Codex Image Generation",
+        description: "Generates or edits images through the ChatGPT/Codex backend API using openai-codex OAuth entitlement. Does not use the public OpenAI Images API.",
+        promptSnippet: "Use codex_image_generation to create an image from a prompt, or to edit referenced/recent images with the Codex/ChatGPT image backend.",
+        promptGuidelines: [
+            "Use codex_image_generation for image generation and image edits when the user asks for pictures, visual variants, or edits to existing images.",
+            "For edits, pass either referenced_image_paths for local image files or num_last_images_to_include for recent conversation images, but not both.",
+        ],
+        executionMode: "sequential",
+        parameters: Type.Object({
+            prompt: Type.String({ description: "Image generation/editing prompt. Be specific about the desired final image." }),
+            referenced_image_paths: Type.Optional(Type.Array(Type.String({ description: "Local filesystem image path to edit." }), { description: `Optional local image paths to edit. At most ${MAX_EDIT_IMAGES}.` })),
+            num_last_images_to_include: Type.Optional(Type.Number({ description: `Use the last N conversation images as edit references. Must be between 1 and ${MAX_EDIT_IMAGES}.` })),
+        }),
+        async execute(toolCallId, params, signal, _onUpdate, ctx) {
+            validateImageArgs(params);
+            const images = await collectEditImages(params, ctx.cwd, ctx.sessionManager.getBranch());
+            const operation = images.length > 0 ? "edit" : "generate";
+            const endpoint = operation === "edit" ? "edits" : "generations";
+            const auth = await getCodexImageAuth();
+            const response = await postCodexImageRequest(endpoint, createRequest(params.prompt, images), auth, signal, options.baseUrl);
+            const result = firstImageB64(response);
+            const saved = await saveGeneratedImage(context.piboSessionId, toolCallId, result);
+            const details = {
+                provider: OPENAI_CODEX_PROVIDER,
+                api: "codex-chatgpt-images",
+                operation,
+                model: CODEX_IMAGE_MODEL,
+                savedPath: saved.savedPath,
+                artifactId: saved.artifactId,
+                referencedImageCount: images.length,
+                endpoint,
+                created: response.created,
+                background: response.background,
+                quality: response.quality,
+                size: response.size,
+            };
+            return {
+                content: [
+                    { type: "image", data: result, mimeType: "image/png" },
+                    { type: "text", text: `Generated image saved to ${saved.savedPath}` },
+                ],
+                details,
+            };
+        },
+    });
+}
+export function createCodexImageGenerationToolProfile() {
+    return {
+        name: "codex_image_generation",
+        description: "Generate and edit images through the ChatGPT/Codex backend API using openai-codex OAuth.",
+        createDefinition: createCodexImageGenerationToolDefinition,
+    };
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"

package/dist/apps/vscode-artifacts/pibo-vscode-ext-1.4.3.vsix DELETED Viewed

Binary file