codex-xai-oauth 0.1.0 → 0.2.0

package/dist/mcp/server.js

@@ -30948,7 +30948,7 @@ var StdioServerTransport = class {
 };
 
 // src/version.ts
-var PACKAGE_VERSION = "0.1.0";
+var PACKAGE_VERSION = "0.2.0";
 
 // src/xai/constants.ts
 var XAI_BASE_URL = "https://api.x.ai/v1";
@@ -32241,7 +32241,7 @@ var Ky = class _Ky {
   }
   #getNormalizedOptions() {
     if (!this.#cachedNormalizedOptions) {
-      const { hooks, json: json2, parseJson, stringifyJson, searchParams, timeout: timeout2, totalTimeout, throwHttpErrors, fetch, ...normalizedOptions } = this.#options;
+      const { hooks, json: json2, parseJson, stringifyJson, searchParams, timeout: timeout2, totalTimeout, throwHttpErrors, fetch: fetch2, ...normalizedOptions } = this.#options;
       this.#cachedNormalizedOptions = Object.freeze(normalizedOptions);
     }
     return this.#cachedNormalizedOptions;
@@ -32623,6 +32623,80 @@ async function xaiRequest(path, options) {
   });
 }
 
+// src/xai/image-artifacts.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+async function artifactImageGenerationResult(result, options) {
+  const artifacts = [];
+  const images = result.data ?? [];
+  for (let index = 0; index < images.length; index += 1) {
+    const image = images[index];
+    if (!image) {
+      continue;
+    }
+    const artifact = await imageArtifactForPayload(image, index, options);
+    if (artifact) {
+      artifacts.push(artifact);
+    }
+  }
+  return { ...result, artifacts };
+}
+async function imageArtifactForPayload(image, index, options) {
+  if (image.b64_json) {
+    const mimeType = image.mime_type ?? "image/png";
+    const path = artifactPath(options.artifactDir, index, mimeType);
+    await writeArtifact(path, Buffer.from(image.b64_json, "base64"));
+    return {
+      index,
+      mime_type: mimeType,
+      path,
+      source: "base64",
+      status: "saved"
+    };
+  }
+  if (!image.url) {
+    return void 0;
+  }
+  return downloadImageArtifact({ ...image, url: image.url }, index, options);
+}
+async function downloadImageArtifact(image, index, options) {
+  try {
+    const response = await (options.fetchImage ?? fetch)(image.url);
+    if (!response.ok) {
+      throw new Error(`download failed with status ${response.status}`);
+    }
+    const mimeType = image.mime_type ?? response.headers.get("content-type") ?? "image/png";
+    const path = artifactPath(options.artifactDir, index, mimeType);
+    await writeArtifact(path, Buffer.from(await response.arrayBuffer()));
+    return {
+      index,
+      mime_type: mimeType,
+      path,
+      source: "url",
+      status: "saved",
+      url: image.url
+    };
+  } catch (error51) {
+    return {
+      error: error51 instanceof Error ? error51.message : String(error51),
+      index,
+      source: "url",
+      status: "remote",
+      url: image.url
+    };
+  }
+}
+async function writeArtifact(path, bytes) {
+  await mkdir(join3(path, ".."), { recursive: true });
+  await writeFile(path, bytes);
+}
+function artifactPath(artifactDir, index, mimeType) {
+  return join3(artifactDir, `image-${index + 1}.${extensionForMime(mimeType)}`);
+}
+function extensionForMime(mimeType) {
+  return mimeType.includes("jpeg") || mimeType.includes("jpg") ? "jpg" : "png";
+}
+
 // src/xai/media.ts
 async function xaiImageGenerate(args) {
   const body = {
@@ -32644,6 +32718,12 @@ async function xaiImageGenerate(args) {
   const parsed = await response.json();
   return isRecord(parsed) ? parsed : {};
 }
+async function xaiImageGenerateWithArtifacts(args) {
+  const result = await xaiImageGenerate(args);
+  return artifactImageGenerationResult(result, {
+    artifactDir: args.artifactDir
+  });
+}
 async function xaiTts(args) {
   const codec2 = args.codec || args.format;
   const body = {
@@ -32897,19 +32977,34 @@ function registerMediaTools(server) {
         n: external_exports.number().int().min(1).max(10).optional(),
         resolution: external_exports.enum(["1k", "2k"]).optional(),
         response_format: external_exports.enum(["url", "b64_json"]).optional(),
-        size: external_exports.string().optional()
+        size: external_exports.string().optional(),
+        artifact_dir: external_exports.string().optional()
       })
     },
-    async ({ prompt, model, n, resolution, response_format, size }) => textJson(
-      await xaiImageGenerate({
+    async ({
+      prompt,
+      model,
+      n,
+      resolution,
+      response_format,
+      size,
+      artifact_dir
+    }) => {
+      const args = {
         prompt,
         ...model ? { model } : {},
         ...n ? { n } : {},
         ...resolution ? { resolution } : {},
         ...response_format ? { response_format } : {},
         ...size ? { size } : {}
-      })
-    )
+      };
+      return textJson(
+        artifact_dir ? await xaiImageGenerateWithArtifacts({
+          ...args,
+          artifactDir: artifact_dir
+        }) : await xaiImageGenerate(args)
+      );
+    }
   );
   server.registerTool(
     "xai_tts",

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "0.1.0";
+export declare const PACKAGE_VERSION = "0.2.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/xai/constants.d.ts

@@ -12,6 +12,6 @@ export declare const XAI_REDIRECT_PATH = "/callback";
 export declare const OPENAI_COMPAT_HOST = "127.0.0.1";
 export declare const OPENAI_COMPAT_PORT = 8787;
 export declare const REFRESH_SKEW_MS: number;
-export declare const USER_AGENT = "codex-xai-oauth/0.1.0";
+export declare const USER_AGENT = "codex-xai-oauth/0.2.0";
 export declare function xaiBaseUrl(): string;
 //# sourceMappingURL=constants.d.ts.map

package/dist/xai/image-artifacts.d.ts

@@ -0,0 +1,33 @@
+export type ImagePayload = {
+    readonly b64_json?: string;
+    readonly mime_type?: string;
+    readonly url?: string;
+};
+export type ImageGenerationWithData = {
+    readonly data?: readonly ImagePayload[];
+    readonly [key: string]: unknown;
+};
+export type SavedImageArtifact = {
+    readonly index: number;
+    readonly mime_type: string;
+    readonly path: string;
+    readonly source: "base64" | "url";
+    readonly status: "saved";
+    readonly url?: string;
+};
+export type RemoteImageArtifact = {
+    readonly error: string;
+    readonly index: number;
+    readonly source: "url";
+    readonly status: "remote";
+    readonly url: string;
+};
+export type ImageArtifact = SavedImageArtifact | RemoteImageArtifact;
+export type ImageArtifactGenerationResult = ImageGenerationWithData & {
+    readonly artifacts: readonly ImageArtifact[];
+};
+export declare function artifactImageGenerationResult(result: ImageGenerationWithData, options: {
+    readonly artifactDir: string;
+    readonly fetchImage?: (url: string) => Promise<Response>;
+}): Promise<ImageArtifactGenerationResult>;
+//# sourceMappingURL=image-artifacts.d.ts.map

package/dist/xai/index.d.ts

@@ -1,7 +1,7 @@
 export { beginOAuth, startCallbackServer } from "./browser-oauth.js";
 export { credentialStatus, resolveXaiCredentials } from "./credentials.js";
 export { beginDeviceOAuth, pollDeviceToken, requestDeviceCode, } from "./device-oauth.js";
-export { xaiImageGenerate, xaiTts, xaiVideoGenerate } from "./media.js";
+export { xaiImageGenerate, xaiImageGenerateWithArtifacts, xaiTts, xaiVideoGenerate, } from "./media.js";
 export { buildAuthorizeUrl, discoverXaiOAuth, exchangeCodeForToken, pkcePair, refreshAccessToken, storedAuthFromToken, } from "./oauth.js";
 export { xaiChatCompletions, xaiResponses } from "./responses.js";
 export { authPath, defaultAuthPath, defaultGrokAuthPath, grokAuthPath, readGrokStoredAuth, readStoredAuth, writeStoredAuth, } from "./storage.js";

package/dist/xai/media.d.ts

@@ -1,3 +1,4 @@
+import { type ImageArtifactGenerationResult } from "./image-artifacts.js";
 export declare function xaiImageGenerate(args: {
     readonly model?: string;
     readonly n?: number;
@@ -6,6 +7,15 @@ export declare function xaiImageGenerate(args: {
     readonly response_format?: "url" | "b64_json";
     readonly size?: string;
 }): Promise<Record<string, unknown>>;
+export declare function xaiImageGenerateWithArtifacts(args: {
+    readonly artifactDir: string;
+    readonly model?: string;
+    readonly n?: number;
+    readonly prompt: string;
+    readonly resolution?: "1k" | "2k";
+    readonly response_format?: "url" | "b64_json";
+    readonly size?: string;
+}): Promise<ImageArtifactGenerationResult>;
 export declare function xaiTts(args: {
     readonly bit_rate?: number;
     readonly codec?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-xai-oauth",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Codex plugin exposing xAI/Grok OAuth and API-key tools through a local MCP server.",
   "type": "module",
   "main": "./dist/mcp/server.js",

package/skills/xai-grok/SKILL.md

@@ -14,7 +14,7 @@ Use the bundled MCP tools when the user asks for xAI, Grok, Grok Imagine, xAI im
 - `xai_generate_text`: generate text with Grok through xAI Responses.
 - `xai_web_search`: answer with xAI server-side web search.
 - `xai_x_search`: answer with xAI server-side X search. Do not pass both allowed and excluded handles.
-- `xai_image_generate`: generate images with xAI `/images/generations`.
+- `xai_image_generate`: generate images with xAI `/images/generations`. Pass `artifact_dir` when the user wants local files; URL and `b64_json` images are saved there and returned in `artifacts`.
 - `xai_tts`: generate speech audio.
 - `xai_video_generate`: generate video.
 
@@ -47,3 +47,18 @@ To check status:
 ```bash
 codex-xai-oauth status
 ```
+
+## Image Generation
+
+Use `xai_image_generate` when the user asks to generate an image, Grok Imagine image, or xAI image. Defaults are `model: grok-imagine-image`, `response_format: url`, and `n: 1`.
+
+Supported image options:
+
+- `prompt`: required image prompt.
+- `n`: number of images.
+- `resolution`: `1k` or `2k`.
+- `response_format`: `url` or `b64_json`.
+- `size`: provider-specific size string.
+- `artifact_dir`: local directory for saved image artifacts.
+
+When `artifact_dir` is provided, return both the upstream JSON and the `artifacts` metadata. Each saved artifact includes a local `path`, `mime_type`, `source`, and `status`. If a remote URL cannot be downloaded, preserve the upstream `url` with `status: remote` instead of hiding it.