ima2-gen 1.1.18 → 1.1.19

package/lib/grokVideoAdapter.js

@@ -45,6 +45,25 @@ function sourceImageUrl(image, mime) {
     const detected = mime || detectImageMimeFromB64(image) || "image/png";
     return `data:${detected};base64,${image}`;
 }
+/** Map aspect ratio + resolution to pixel dimensions for white canvas injection. */
+function aspectToCanvas(aspectRatio, resolution) {
+    const base = resolution === "720p" ? 720 : 480;
+    const ratios = {
+        "16:9": [16, 9], "9:16": [9, 16], "4:3": [4, 3], "3:4": [3, 4],
+        "3:2": [3, 2], "2:3": [2, 3], "1:1": [1, 1], "auto": [16, 9],
+    };
+    const [w, h] = ratios[aspectRatio] || [16, 9];
+    if (w >= h)
+        return { width: Math.round(base * w / h), height: base };
+    return { width: base, height: Math.round(base * h / w) };
+}
+/** Generate a minimal white PNG as base64 (no external deps). */
+function generateWhiteCanvasB64() {
+    // Minimal valid 1x1 white PNG, scaled conceptually — xAI will accept any valid PNG
+    // For simplicity, use a tiny white PNG (the model doesn't use it as a real frame)
+    const PNG_1x1_WHITE = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/58BAwAHBQKhPX8EPAAAAABJRU5ErkJggg==";
+    return PNG_1x1_WHITE;
+}
 const FAILED_CODE_MAP = {
     invalid_argument: { code: "GROK_VIDEO_REQUEST_FAILED", status: 400 },
     permission_denied: { code: "GROK_VIDEO_REQUEST_FAILED", status: 403 },
@@ -383,11 +402,20 @@ export async function generateVideoViaGrok(prompt, ctx, options = {}) {
     const payload = buildVideoGenerationPayload(plan, { model, sourceImageUrl: srcUrl, referenceImageUrls: refUrls });
     let xaiVideoRequestId;
     let effectiveModel = model;
+    // grokv1.5 doesn't support T2V — inject a white canvas as source image to use I2V path
+    let effectivePayload = payload;
+    if (model === "grok-imagine-video-1.5-preview" && !srcUrl && refUrls.length === 0) {
+        const { width, height } = aspectToCanvas(plan.aspectRatio, plan.resolution);
+        const whiteCanvas = generateWhiteCanvasB64();
+        const canvasSrcUrl = `data:image/png;base64,${whiteCanvas}`;
+        effectivePayload = buildVideoGenerationPayload({ ...plan, prompt: `${plan.prompt}. This is not a start frame — generate freely as a new video.` }, { model, sourceImageUrl: canvasSrcUrl, referenceImageUrls: [] });
+        logEvent("grok", "video:1.5-t2v-canvas", { requestId: options.requestId, width, height });
+    }
     try {
-        xaiVideoRequestId = await startVideoRequest(ctx, payload, options);
+        xaiVideoRequestId = await startVideoRequest(ctx, effectivePayload, options);
     }
     catch (e) {
-        // Fallback: if 1.5-preview fails, retry with base model
+        // Fallback: if 1.5-preview still fails, retry with base model
         if (model !== "grok-imagine-video" && e?.status === 400) {
             effectiveModel = "grok-imagine-video";
             const fallbackPayload = buildVideoGenerationPayload(plan, { model: effectiveModel, sourceImageUrl: srcUrl, referenceImageUrls: refUrls });

package/lib/grokVideoAdapter.ts

@@ -124,6 +124,26 @@ function sourceImageUrl(image: string, mime?: string | null): string {
   return `data:${detected};base64,${image}`;
 }
 
+/** Map aspect ratio + resolution to pixel dimensions for white canvas injection. */
+function aspectToCanvas(aspectRatio: string, resolution: string): { width: number; height: number } {
+  const base = resolution === "720p" ? 720 : 480;
+  const ratios: Record<string, [number, number]> = {
+    "16:9": [16, 9], "9:16": [9, 16], "4:3": [4, 3], "3:4": [3, 4],
+    "3:2": [3, 2], "2:3": [2, 3], "1:1": [1, 1], "auto": [16, 9],
+  };
+  const [w, h] = ratios[aspectRatio] || [16, 9];
+  if (w >= h) return { width: Math.round(base * w / h), height: base };
+  return { width: base, height: Math.round(base * h / w) };
+}
+
+/** Generate a minimal white PNG as base64 (no external deps). */
+function generateWhiteCanvasB64(): string {
+  // Minimal valid 1x1 white PNG, scaled conceptually — xAI will accept any valid PNG
+  // For simplicity, use a tiny white PNG (the model doesn't use it as a real frame)
+  const PNG_1x1_WHITE = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/58BAwAHBQKhPX8EPAAAAABJRU5ErkJggg==";
+  return PNG_1x1_WHITE;
+}
+
 const FAILED_CODE_MAP: Record<string, { code: string; status: number }> = {
   invalid_argument: { code: "GROK_VIDEO_REQUEST_FAILED", status: 400 },
   permission_denied: { code: "GROK_VIDEO_REQUEST_FAILED", status: 403 },
@@ -449,10 +469,24 @@ export async function generateVideoViaGrok(prompt: string, ctx: RouteRuntimeCont
   const payload = buildVideoGenerationPayload(plan, { model, sourceImageUrl: srcUrl, referenceImageUrls: refUrls });
   let xaiVideoRequestId: string;
   let effectiveModel = model;
+
+  // grokv1.5 doesn't support T2V — inject a white canvas as source image to use I2V path
+  let effectivePayload = payload;
+  if (model === "grok-imagine-video-1.5-preview" && !srcUrl && refUrls.length === 0) {
+    const { width, height } = aspectToCanvas(plan.aspectRatio, plan.resolution);
+    const whiteCanvas = generateWhiteCanvasB64();
+    const canvasSrcUrl = `data:image/png;base64,${whiteCanvas}`;
+    effectivePayload = buildVideoGenerationPayload(
+      { ...plan, prompt: `${plan.prompt}. This is not a start frame — generate freely as a new video.` },
+      { model, sourceImageUrl: canvasSrcUrl, referenceImageUrls: [] },
+    );
+    logEvent("grok", "video:1.5-t2v-canvas", { requestId: options.requestId, width, height });
+  }
+
   try {
-    xaiVideoRequestId = await startVideoRequest(ctx, payload, options);
+    xaiVideoRequestId = await startVideoRequest(ctx, effectivePayload, options);
   } catch (e: any) {
-    // Fallback: if 1.5-preview fails, retry with base model
+    // Fallback: if 1.5-preview still fails, retry with base model
     if (model !== "grok-imagine-video" && e?.status === 400) {
       effectiveModel = "grok-imagine-video";
       const fallbackPayload = buildVideoGenerationPayload(plan, { model: effectiveModel, sourceImageUrl: srcUrl, referenceImageUrls: refUrls });

package/lib/historyList.js

@@ -34,6 +34,7 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
             url: `/generated/${rel.split("/").map(encodeURIComponent).join("/")}`,
             mediaType: meta?.mediaType || (/\.mp4$/i.test(name) ? "video" : "image"),
             video: meta?.video || null,
+            videoSeries: meta?.videoSeries || null,
             createdAt: meta?.createdAt || st?.mtimeMs || 0,
             prompt: meta?.prompt || null,
             userPrompt: meta?.userPrompt || meta?.prompt || null,

package/lib/historyList.ts

@@ -36,6 +36,7 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
       url: `/generated/${rel.split("/").map(encodeURIComponent).join("/")}`,
       mediaType: meta?.mediaType || (/\.mp4$/i.test(name) ? "video" : "image"),
       video: meta?.video || null,
+      videoSeries: meta?.videoSeries || null,
       createdAt: meta?.createdAt || st?.mtimeMs || 0,
       prompt: meta?.prompt || null,
       userPrompt: meta?.userPrompt || meta?.prompt || null,

package/lib/videoSeriesChain.js

@@ -0,0 +1,24 @@
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+/**
+ * Scan generatedDir for videos with matching topic, return the most recent N revisedPrompts.
+ */
+export async function getVideoSeriesChain(generatedDir, topic, limit = 4) {
+    if (!topic.trim())
+        return [];
+    const entries = await readdir(generatedDir).catch(() => []);
+    const sidecars = entries.filter((e) => e.endsWith(".mp4.json"));
+    const matches = [];
+    for (const sidecar of sidecars) {
+        try {
+            const raw = await readFile(join(generatedDir, sidecar), "utf-8");
+            const meta = JSON.parse(raw);
+            if (meta.videoSeries?.topic === topic && meta.revisedPrompt) {
+                matches.push({ revisedPrompt: meta.revisedPrompt, createdAt: meta.createdAt ?? 0 });
+            }
+        }
+        catch { /* skip unreadable */ }
+    }
+    matches.sort((a, b) => b.createdAt - a.createdAt);
+    return matches.slice(0, limit).reverse().map((m) => m.revisedPrompt);
+}

package/lib/videoSeriesChain.ts

@@ -0,0 +1,29 @@
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+
+interface VideoSeriesMeta {
+  revisedPrompt?: string;
+  createdAt?: number;
+  videoSeries?: { topic: string; chainIndex?: number };
+}
+
+/**
+ * Scan generatedDir for videos with matching topic, return the most recent N revisedPrompts.
+ */
+export async function getVideoSeriesChain(generatedDir: string, topic: string, limit = 4): Promise<string[]> {
+  if (!topic.trim()) return [];
+  const entries = await readdir(generatedDir).catch(() => [] as string[]);
+  const sidecars = entries.filter((e) => e.endsWith(".mp4.json"));
+  const matches: Array<{ revisedPrompt: string; createdAt: number }> = [];
+  for (const sidecar of sidecars) {
+    try {
+      const raw = await readFile(join(generatedDir, sidecar), "utf-8");
+      const meta: VideoSeriesMeta = JSON.parse(raw);
+      if (meta.videoSeries?.topic === topic && meta.revisedPrompt) {
+        matches.push({ revisedPrompt: meta.revisedPrompt, createdAt: meta.createdAt ?? 0 });
+      }
+    } catch { /* skip unreadable */ }
+  }
+  matches.sort((a, b) => b.createdAt - a.createdAt);
+  return matches.slice(0, limit).reverse().map((m) => m.revisedPrompt);
+}

package/node_modules/progrok/README.md

@@ -1,6 +1,74 @@
 # progrok
 
-Use Grok models for free via OAuth proxy. No API key needed.
+[![npm version](https://img.shields.io/npm/v/progrok.svg)](https://www.npmjs.com/package/progrok)
+[![license: MIT](https://img.shields.io/badge/license-MIT-16a085.svg)](./LICENSE)
+[![docs](https://img.shields.io/badge/docs-GitHub%20Pages-4cc9a6.svg)](https://lidge-jun.github.io/progrok/)
+[![node](https://img.shields.io/badge/node-%3E%3D18-2d3748.svg)](./package.json)
+
+Activate your xAI Grok OAuth session as a local API and tool surface.
+
+`progrok` is an OAuth bridge for Grok. It signs in with your xAI account, stores
+a refreshable local OAuth session, and activates that session through two
+developer-facing surfaces:
+
+1. an OpenAI-compatible localhost proxy that forwards `/v1/*` requests to
+   `api.x.ai`, and
+2. direct CLI commands for Grok workflows that need source selection, JSON
+   output, async polling, local files, or machine-readable metadata.
+
+The point is not only "no API key." The point is that Hermes Agent, OpenClaw,
+and Grok Build-style coding workflows all rely on the same xAI OAuth credential
+lineage: the xAI account session is the authority, and local tools need a way to
+turn that session into a programmable endpoint. progrok is that activation tool.
+Point the OpenAI SDK, curl scripts, or agent tools at `127.0.0.1:18645` and let
+progrok inject the real xAI bearer token locally.
+
+> Requires an active SuperGrok subscription. progrok does not bypass xAI account
+> access, quotas, pricing, or product limits.
+
+## Links
+
+- Live docs: [lidge-jun.github.io/progrok](https://lidge-jun.github.io/progrok/)
+- OAuth bridge: [lidge-jun.github.io/progrok/docs/concepts/oauth-bridge](https://lidge-jun.github.io/progrok/docs/concepts/oauth-bridge)
+- Quick start: [lidge-jun.github.io/progrok/docs/quickstart](https://lidge-jun.github.io/progrok/docs/quickstart)
+- npm: [npmjs.com/package/progrok](https://www.npmjs.com/package/progrok)
+- Repository: [github.com/lidge-jun/progrok](https://github.com/lidge-jun/progrok)
+
+## Why OAuth
+
+xAI account access is session-based in the tools that made this workflow
+useful. Hermes Agent and OpenClaw document the shared xAI OAuth client
+identifier used by progrok, and Grok Build-style coding workflows benefit from
+the same model: authenticate once with the xAI account, then expose Grok to
+developer tooling through a local API surface.
+
+That changes the shape of the problem:
+
+- the user account and subscription decide what models and tools are available;
+- the local machine holds the refreshable credential;
+- existing SDKs and agents expect a base URL plus an API key;
+- Grok media, search, and model discovery need more workflow glue than a raw
+  HTTP proxy provides.
+
+progrok handles that glue. It activates the OAuth credential as a proxy for
+OpenAI-compatible clients and as direct commands for search, images, video,
+models, and capability discovery.
+
+## What "activation tool" means
+
+After `progrok login`, the stored OAuth session powers every surface below:
+
+| Surface | Command or URL | What gets activated |
+| --- | --- | --- |
+| OpenAI-compatible API | `http://127.0.0.1:18645/v1/*` | Chat, Responses, reasoning, structured output, server-side tools, files, batches, and other HTTP xAI API paths your account can access. |
+| Current search | `progrok search` | Grok Responses with web search, X search, citations, JSON output, and optional reasoning effort. |
+| Image workflows | `progrok image` | Imagine generation and editing with local reference files and output handling. |
+| Video workflows | `progrok video` | Async video submission, polling, progress display, and download handling. |
+| Coding models | `grok-build-0.1` through the proxy | Grok Build-style coding work from clients that can point at a local OpenAI-compatible endpoint. |
+| Agent discovery | `progrok capabilities --json` | Machine-readable ports, commands, models, endpoints, and auth requirements. |
+
+The placeholder `OPENAI_API_KEY` or `Authorization` value is only there to
+satisfy client libraries. progrok replaces it before forwarding the request.
 
 ## Install
 
@@ -11,43 +79,253 @@ npm install -g progrok
 ## Quick Start
 
 ```bash
-# 1. Login with your xAI account (SuperGrok subscription required)
+# 1. Activate your xAI OAuth session.
 progrok login
 
-# 2. Start the proxy server
+# SSH or remote machine:
+progrok login --device-code
+
+# 2. Start the OpenAI-compatible local proxy.
 progrok proxy
 
-# 3. Use from any OpenAI-compatible client
+# 3. Call Grok through localhost.
 curl http://127.0.0.1:18645/v1/chat/completions \
   -H "Authorization: Bearer anything" \
   -H "Content-Type: application/json" \
-  -d '{"model": "grok-4.3", "messages": [{"role": "user", "content": "Hello"}]}'
+  -d '{"model":"grok-4.3","messages":[{"role":"user","content":"Hello"}]}'
+```
+
+The proxy replaces the placeholder `Authorization` value with your stored xAI
+OAuth bearer token before forwarding the request. The API key value in your
+client can be any non-empty placeholder.
+
+For direct tool activation, the proxy process is optional:
+
+```bash
+progrok search --x --json "Grok Build release discussion"
+progrok image "a precise product diagram of an OAuth bridge CLI" --output ./out
+progrok video "a local proxy turning on Grok tools" --duration 5
+progrok models --detail
+progrok capabilities --json
+```
+
+## OpenAI SDK Example
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://127.0.0.1:18645/v1",
+    api_key="anything",
+)
+
+result = client.chat.completions.create(
+    model="grok-4.3",
+    messages=[{"role": "user", "content": "Explain MCP in 5 bullets"}],
+)
+
+print(result.choices[0].message.content)
+```
+
+Shell configuration for tools that respect OpenAI-compatible environment
+variables:
+
+```bash
+export OPENAI_BASE_URL=http://127.0.0.1:18645/v1
+export OPENAI_API_KEY=anything
 ```
 
 ## Commands
 
-| Command | Description |
-|---------|-------------|
-| `progrok login` | OAuth login via browser |
-| `progrok login --device-code` | Login via device code (SSH/remote) |
-| `progrok proxy` | Start OpenAI-compatible proxy on port 18645 |
-| `progrok chat` | Open web chat UI in browser |
-| `progrok models` | List available Grok models |
-| `progrok status` | Show auth status |
-| `progrok logout` | Remove stored credentials |
+| Command | Use it for |
+| --- | --- |
+| `progrok login` | Browser OAuth login with your xAI account. |
+| `progrok login --device-code` | OAuth login for SSH, CI shells, or remote machines. |
+| `progrok logout` | Remove stored local credentials. |
+| `progrok status` | Check whether a local OAuth session exists. |
+| `progrok proxy` | Start the local OpenAI-compatible proxy on `127.0.0.1:18645`. |
+| `progrok chat` | Open the local browser chat UI on `127.0.0.1:18646`. |
+| `progrok models --detail` | List model aliases, pricing, context windows, and media models. |
+| `progrok search <query>` | Search web and X sources through Grok Responses tools. |
+| `progrok search <query> --web` | Restrict search to web sources. |
+| `progrok search <query> --x` | Restrict search to X sources. |
+| `progrok search <query> --reasoning high` | Add reasoning effort to a search request. |
+| `progrok image <prompt>` | Generate an Imagine image. |
+| `progrok image <prompt> --ref ./input.png` | Edit or compose from a reference image. |
+| `progrok video <prompt>` | Submit a text-to-video job and poll until completion. |
+| `progrok video <prompt> --image ./input.png` | Submit an image-to-video job. |
+| `progrok capabilities --json` | Print machine-readable command, model, and endpoint metadata. |
+| `progrok skill` | Print an agent-oriented usage guide. |
+
+## Native Search
+
+`progrok search` calls xAI's Responses API directly with `web_search` and
+`x_search` tools. It does not require the proxy process to be running because it
+loads the same OAuth session directly.
+
+```bash
+progrok search "latest Astro release"
+progrok search --web "Node.js 22 features"
+progrok search --x "grok API launch"
+progrok search --json "rust async traits"
+progrok search --model grok-4.20-multi-agent-0309 --reasoning xhigh \
+  "compare current open-source browser automation tools"
+```
+
+Reasoning effort values: `none`, `low`, `medium`, `high`, `xhigh`.
+
+## Image and Video
+
+Image generation:
+
+```bash
+progrok image "a crisp terminal UI product shot for a CLI called progrok"
+progrok image "make this diagram cleaner" --ref ./diagram.png --output ./out
+```
+
+Video generation:
+
+```bash
+progrok video "a terminal command expanding into a network diagram"
+progrok video "turn this interface into a smooth product demo" --image ./screen.png
+progrok video "short launch animation" --model grok-imagine-video-1.5-preview
+```
+
+Media commands call xAI endpoints directly with your OAuth session and poll async
+jobs until completion.
+
+## Proxy Coverage
+
+The proxy forwards every HTTP `/v1/*` path to `api.x.ai`, so it can activate the
+xAI API surface available to your account:
+
+- Chat Completions and Responses
+- reasoning, citations, structured output, and tool calls
+- image generation and editing
+- video generation, editing, extension, and polling
+- text-to-speech, speech-to-text, and realtime client-secret minting
+- files, batches, tokenizer, models, and collection search
+
+WebSocket endpoints are not proxied. For realtime voice streams, mint a client
+secret through the HTTP proxy and connect directly to xAI's WebSocket endpoint.
+
+## Models
+
+| Model | Best for | Context | Notes |
+| --- | --- | --- | --- |
+| `grok-4.3` | Default chat, tools, search, vision | 1M | Also available through common Grok aliases. |
+| `grok-build-0.1` | Fast agentic coding | 256K | Good default for Grok Build-style coding tools through the OAuth proxy. |
+| `grok-4.20-0309-reasoning` | Deep reasoning | 200K+ | Legacy reasoning model. |
+| `grok-4.20-0309-non-reasoning` | Lower-latency text | 200K+ | Legacy non-reasoning model. |
+| `grok-4.20-multi-agent-0309` | Deep research | 200K+ | Supports high and xhigh effort. |
+| `grok-imagine-image` | Image generation and editing | - | Billed per image. |
+| `grok-imagine-image-quality` | Higher-quality image output | - | Billed per image. |
+| `grok-imagine-video` | Video generation and editing | - | Billed per second. |
+| `grok-imagine-video-1.5-preview` | Video v1.5 preview | - | Improved image-to-video behavior. |
+
+Run the live metadata command before relying on a model in automation:
+
+```bash
+progrok models --detail
+progrok capabilities --json
+```
 
 ## How It Works
 
-progrok authenticates with xAI via OAuth (the same flow as Grok web app), then runs a local proxy that injects your OAuth token into API requests. Any OpenAI-compatible client can connect to the proxy — no API key purchase required.
+```text
+OpenAI client, coding agent, curl script, or local tool
+  -> http://127.0.0.1:18645/v1/*
+  -> progrok loads ~/.progrok/auth.json
+  -> progrok refreshes the token if needed
+  -> progrok injects the xAI OAuth bearer token
+  -> https://api.x.ai/v1/*
+```
+
+Credentials are stored locally at `~/.progrok/auth.json` and refreshed before
+expiry. Treat that file like any other account credential.
+
+The direct command path is similar but skips the proxy server:
+
+```text
+progrok search / image / video / models / capabilities
+  -> load the same local OAuth session
+  -> call the relevant xAI endpoint
+  -> add CLI-specific behavior such as polling, files, or JSON output
+```
+
+## Relationship to Hermes Agent, OpenClaw, and Grok Build
+
+progrok's OAuth client attribution comes from Hermes Agent and OpenClaw under
+their MIT licenses. Those projects demonstrated the important part: Grok can be
+made useful to local developer tools through xAI OAuth rather than through a
+manually provisioned API key.
+
+progrok takes that pattern and packages it as a focused bridge:
+
+- Hermes Agent and OpenClaw establish the shared OAuth client lineage.
+- Grok Build-style workflows need a coding model reachable from agent tools.
+- progrok provides the localhost OpenAI-compatible endpoint and direct commands
+  that let those tools use the same authenticated account session.
+
+This is why the documentation describes progrok as an activation tool. Login is
+the authorization step; the proxy and CLI commands are the activated surfaces.
 
-## Supported Models
+## Security Notes
 
-- `grok-4.3` (default) — General-purpose reasoning
-- `grok-4.20-beta-latest-reasoning` — Deep reasoning
-- `grok-4.20-beta-latest-non-reasoning` — Fast responses
-- `grok-build-0.1` — Code-optimized
-- And more via `progrok models`
+- The proxy binds to localhost by default.
+- Do not expose the proxy port to a public network without adding your own access
+  controls.
+- The placeholder API key sent by OpenAI-compatible clients is ignored by the
+  proxy and replaced with your xAI OAuth token.
+- `progrok logout` removes the local credential file.
+- Requests are forwarded to xAI. Sensitive prompt data should be handled under
+  the same policy you use for direct xAI API usage.
+- The OAuth file enables account-backed access. Do not commit it, sync it to
+  untrusted machines, or share it between users.
+
+## Troubleshooting
+
+### `progrok status` says no session
+
+Run `progrok login` again. On remote machines, use `progrok login --device-code`.
+
+### The proxy starts but clients fail
+
+Check that the client points to:
+
+```bash
+http://127.0.0.1:18645/v1
+```
+
+Also check that the client sends a non-empty API key placeholder.
+
+### Port 18645 is already in use
+
+Stop the existing process or start the proxy on another port if your version
+supports a port flag. Then update `OPENAI_BASE_URL` accordingly.
+
+### A model returns 404 or 400
+
+Run:
+
+```bash
+progrok models --detail
+```
+
+Model aliases and preview names can change. Use the live list before scripting a
+long-running workflow.
+
+### Search, image, or video commands fail
+
+These commands call xAI directly with OAuth and may be subject to product access,
+rate limits, quota, and account capability. Start with:
+
+```bash
+progrok status
+progrok capabilities --json
+```
 
 ## License
 
-MIT — See [THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md) for OAuth client attribution.
+MIT. See [THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md) for OAuth client
+attribution.