pi-codex-image-gen 0.1.0

package/extensions/codex-image-gen.ts

@@ -0,0 +1,468 @@
+/**
+ * Project-local Codex image generation extension.
+ *
+ * Registers `codex_generate_image`, a tool that uses Pi's existing
+ * openai-codex ChatGPT/Codex auth to call the Codex Responses backend with the
+ * native `image_generation` tool. The backend maps that tool to gpt-image-2.
+ */
+
+import { readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { type ExtensionAPI, getAgentDir, withFileMutationQueue } from "@mariozechner/pi-coding-agent";
+import { type Static, Type } from "typebox";
+
+const PROVIDER = "openai-codex";
+const DEFAULT_MODEL = "gpt-5.5";
+const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const DEFAULT_SAVE_MODE = "global";
+const OPENAI_BETA_HEADER = "responses=experimental";
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+
+const SAVE_MODES = ["none", "project", "global", "custom"] as const;
+type SaveMode = (typeof SAVE_MODES)[number];
+
+const OUTPUT_FORMATS = ["png", "jpeg", "webp"] as const;
+type OutputFormat = (typeof OUTPUT_FORMATS)[number];
+
+// --- #1: Retry helpers with exponential backoff + jitter ---
+
+function isRetryableStatus(status: number, errorText: string): boolean {
+	if ([429, 500, 502, 503, 504].includes(status)) return true;
+	return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
+}
+
+function backoffMs(attempt: number): number {
+	const jitter = 0.9 + Math.random() * 0.2; // matches codex-rs jitter range
+	return BASE_DELAY_MS * 2 ** (attempt - 1) * jitter;
+}
+
+// --- Tool parameter schema ---
+
+const TOOL_PARAMS = Type.Object({
+	prompt: Type.String({ description: "The image prompt. Be specific about subject, composition, style, text, and constraints." }),
+	model: Type.Optional(
+		Type.String({ description: `Codex model that should invoke image generation. Defaults to ${DEFAULT_MODEL}.` }),
+	),
+	outputFormat: Type.Optional(StringEnum(OUTPUT_FORMATS)),
+	save: Type.Optional(StringEnum(SAVE_MODES)),
+	saveDir: Type.Optional(
+		Type.String({
+			description: "Directory to save the image when save=custom. Relative paths resolve under the current workspace.",
+		}),
+	),
+});
+
+type ToolParams = Static<typeof TOOL_PARAMS>;
+
+// --- Config types ---
+
+interface ExtensionConfig {
+	save?: SaveMode;
+	saveDir?: string;
+	model?: string;
+}
+
+interface SaveConfig {
+	mode: SaveMode;
+	outputDir?: string;
+}
+
+interface GeneratedImage {
+	id: string;
+	status: string;
+	result: string;
+	revisedPrompt?: string;
+}
+
+interface ParsedCodexResponse {
+	image?: GeneratedImage;
+	text: string[];
+	responseId?: string;
+	usage?: unknown;
+}
+
+// --- #11: Typed SSE event discriminated union ---
+
+type CodexSseEvent =
+	| { type: "error"; message?: string; code?: string }
+	| { type: "response.failed"; response?: { error?: { message?: string } } }
+	| { type: "response.created"; response?: { id?: string } }
+	| { type: "response.output_text.delta"; delta?: string }
+	| {
+			type: "response.output_item.done";
+			item?: {
+				type?: string;
+				id?: string | number;
+				status?: string;
+				result?: string;
+				revised_prompt?: string;
+			};
+	  }
+	| { type: "response.completed"; response?: { id?: string; usage?: unknown } };
+
+// --- JWT helpers ---
+
+function decodeJwtPayload(token: string): Record<string, unknown> {
+	const parts = token.split(".");
+	if (parts.length !== 3 || !parts[1]) {
+		throw new Error("OpenAI Codex auth token is not a JWT. Run /login for openai-codex again.");
+	}
+	try {
+		return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8")) as Record<string, unknown>;
+	} catch (error) {
+		throw new Error(`Failed to decode OpenAI Codex auth token: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+function extractChatGptAccountId(token: string): string {
+	const payload = decodeJwtPayload(token);
+	const authClaims = payload[JWT_CLAIM_PATH];
+	if (!authClaims || typeof authClaims !== "object") {
+		throw new Error("OpenAI Codex auth token does not contain ChatGPT auth claims. Run /login for openai-codex again.");
+	}
+	const accountId = (authClaims as Record<string, unknown>).chatgpt_account_id;
+	if (typeof accountId !== "string" || accountId.length === 0) {
+		throw new Error("OpenAI Codex auth token does not contain chatgpt_account_id. Run /login for openai-codex again.");
+	}
+	return accountId;
+}
+
+// --- #10: try/catch readConfigFile replaces racy existsSync + readFileSync ---
+
+function readConfigFile(path: string): ExtensionConfig {
+	try {
+		return JSON.parse(readFileSync(path, "utf8")) ?? {};
+	} catch {
+		return {};
+	}
+}
+
+function loadConfig(cwd: string): ExtensionConfig {
+	const globalConfig = readConfigFile(join(getAgentDir(), "extensions", "codex-image-gen.json"));
+	const projectConfig = readConfigFile(join(cwd, ".pi", "extensions", "codex-image-gen.json"));
+	return { ...globalConfig, ...projectConfig };
+}
+
+// --- Path helpers ---
+
+function resolveUnderCwd(cwd: string, path: string): string {
+	return isAbsolute(path) ? path : resolve(cwd, path);
+}
+
+function sanitizePathPart(value: string, fallback: string): string {
+	const sanitized = value
+		.split("")
+		.map((ch) => (/[a-zA-Z0-9_-]/.test(ch) ? ch : "_"))
+		.join("")
+		.replace(/_+$/g, "");
+	return sanitized || fallback;
+}
+
+// --- #5: resolveSaveConfig accepts pre-loaded config (no double loadConfig) ---
+
+function resolveSaveConfig(params: ToolParams, cwd: string, sessionId: string, config: ExtensionConfig): SaveConfig {
+	const envMode = process.env.PI_CODEX_IMAGE_SAVE_MODE?.toLowerCase();
+	const mode = (params.save || envMode || config.save || DEFAULT_SAVE_MODE) as SaveMode;
+	const safeSessionId = sanitizePathPart(sessionId, "session");
+	if (!SAVE_MODES.includes(mode)) {
+		throw new Error(`Invalid save mode: ${mode}. Expected one of ${SAVE_MODES.join(", ")}.`);
+	}
+	if (mode === "project") {
+		return { mode, outputDir: join(cwd, ".pi", "generated-images", safeSessionId) };
+	}
+	if (mode === "global") {
+		return { mode, outputDir: join(getAgentDir(), "generated-images", safeSessionId) };
+	}
+	if (mode === "custom") {
+		const configuredDir = params.saveDir || process.env.PI_CODEX_IMAGE_SAVE_DIR || config.saveDir;
+		if (!configuredDir || !configuredDir.trim()) {
+			throw new Error("save=custom requires saveDir or PI_CODEX_IMAGE_SAVE_DIR.");
+		}
+		return { mode, outputDir: join(resolveUnderCwd(cwd, configuredDir), safeSessionId) };
+	}
+	return { mode };
+}
+
+// --- Image save helpers ---
+
+function extensionForFormat(outputFormat: OutputFormat): string {
+	return outputFormat === "jpeg" ? "jpg" : outputFormat;
+}
+
+function mimeForFormat(outputFormat: OutputFormat): string {
+	return outputFormat === "jpeg" ? "image/jpeg" : `image/${outputFormat}`;
+}
+
+async function saveImage(base64Data: string, outputFormat: OutputFormat, outputDir: string, imageCallId: string): Promise<string> {
+	const filename = `${sanitizePathPart(imageCallId, "image_generation")}.${extensionForFormat(outputFormat)}`;
+	const filePath = join(outputDir, filename);
+	await withFileMutationQueue(filePath, async () => {
+		await mkdir(outputDir, { recursive: true });
+		await writeFile(filePath, Buffer.from(base64Data, "base64"));
+	});
+	return filePath;
+}
+
+// --- Request building ---
+// #2: prompt_cache_key set to sessionId
+// #7: parallel_tool_calls: false
+// #14: include removed (not needed without reasoning)
+
+function buildRequestBody(params: ToolParams, model: string, outputFormat: OutputFormat, sessionId: string) {
+	return {
+		model,
+		store: false,
+		stream: true,
+		prompt_cache_key: sessionId,
+		instructions:
+			"You are generating bitmap image assets. For this request, call the image_generation tool exactly once. Do not answer with only text unless image generation is unavailable.",
+		input: [
+			{
+				role: "user",
+				content: [{ type: "input_text", text: params.prompt }],
+			},
+		],
+		tools: [{ type: "image_generation", output_format: outputFormat }],
+		tool_choice: "auto",
+		parallel_tool_calls: false,
+		text: { verbosity: "low" },
+	};
+}
+
+// --- SSE parsing ---
+
+function parseSseDataLines(chunk: string): string | undefined {
+	const data = chunk
+		.split("\n")
+		.filter((line) => line.startsWith("data:"))
+		.map((line) => line.slice(5).trim())
+		.join("\n")
+		.trim();
+	return data && data !== "[DONE]" ? data : undefined;
+}
+
+async function parseCodexSse(response: Response, signal?: AbortSignal): Promise<ParsedCodexResponse> {
+	if (!response.body) throw new Error("Codex response did not include a stream body.");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const parsed: ParsedCodexResponse = { text: [] };
+
+	try {
+		while (true) {
+			if (signal?.aborted) throw new Error("Image generation was aborted.");
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+
+			let separator = buffer.indexOf("\n\n");
+			while (separator !== -1) {
+				const chunk = buffer.slice(0, separator);
+				buffer = buffer.slice(separator + 2);
+				const data = parseSseDataLines(chunk);
+				if (data) handleCodexEvent(JSON.parse(data) as CodexSseEvent, parsed);
+				separator = buffer.indexOf("\n\n");
+			}
+		}
+		const remaining = parseSseDataLines(buffer);
+		if (remaining) handleCodexEvent(JSON.parse(remaining) as CodexSseEvent, parsed);
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {
+			// ignored: stream may already be closed
+		}
+		reader.releaseLock();
+	}
+
+	return parsed;
+}
+
+// --- #11: Typed event handler via discriminated union ---
+
+function handleCodexEvent(event: CodexSseEvent, parsed: ParsedCodexResponse): void {
+	if (!event || typeof event !== "object") return;
+
+	switch (event.type) {
+		case "error": {
+			const e = event as Extract<CodexSseEvent, { type: "error" }>;
+			throw new Error(`Codex error: ${e.message || e.code || JSON.stringify(event)}`);
+		}
+		case "response.failed": {
+			const e = event as Extract<CodexSseEvent, { type: "response.failed" }>;
+			throw new Error(e.response?.error?.message || "Codex response failed.");
+		}
+		case "response.created": {
+			const e = event as Extract<CodexSseEvent, { type: "response.created" }>;
+			if (typeof e.response?.id === "string") {
+				parsed.responseId = e.response.id;
+			}
+			break;
+		}
+		case "response.output_text.delta": {
+			const e = event as Extract<CodexSseEvent, { type: "response.output_text.delta" }>;
+			if (typeof e.delta === "string") {
+				parsed.text.push(e.delta);
+			}
+			break;
+		}
+		case "response.output_item.done": {
+			const e = event as Extract<CodexSseEvent, { type: "response.output_item.done" }>;
+			const item = e.item;
+			if (item?.type === "image_generation_call") {
+				if (typeof item.result !== "string" || item.result.length === 0) {
+					throw new Error("Codex image_generation_call did not contain image data.");
+				}
+				parsed.image = {
+					id: String(item.id || "image_generation"),
+					status: String(item.status || "completed"),
+					result: item.result,
+					revisedPrompt: typeof item.revised_prompt === "string" ? item.revised_prompt : undefined,
+				};
+			}
+			break;
+		}
+		case "response.completed": {
+			const e = event as Extract<CodexSseEvent, { type: "response.completed" }>;
+			if (typeof e.response?.id === "string") parsed.responseId = e.response.id;
+			if (e.response?.usage) parsed.usage = e.response.usage;
+			break;
+		}
+	}
+}
+
+// --- #1: requestImage with retry + backoff + jitter ---
+
+async function requestImage(
+	params: ToolParams,
+	token: string,
+	accountId: string,
+	model: string,
+	outputFormat: OutputFormat,
+	sessionId: string,
+	signal?: AbortSignal,
+): Promise<ParsedCodexResponse> {
+	const body = JSON.stringify(buildRequestBody(params, model, outputFormat, sessionId));
+	const headers: Record<string, string> = {
+		Authorization: `Bearer ${token}`,
+		"chatgpt-account-id": accountId,
+		originator: "pi",
+		"OpenAI-Beta": OPENAI_BETA_HEADER,
+		accept: "text/event-stream",
+		"content-type": "application/json",
+	};
+
+	for (let attempt = 1; attempt <= MAX_RETRIES + 1; attempt++) {
+		if (signal?.aborted) throw new Error("Image generation was aborted.");
+
+		const response = await fetch(CODEX_RESPONSES_URL, {
+			method: "POST",
+			headers,
+			body,
+			signal,
+		});
+
+		if (!response.ok) {
+			const errorText = await response.text();
+			if (attempt <= MAX_RETRIES && isRetryableStatus(response.status, errorText)) {
+				const delay = backoffMs(attempt);
+				await new Promise<void>((resolve) => setTimeout(resolve, delay));
+				continue;
+			}
+			throw new Error(`Codex image generation request failed (${response.status}): ${errorText}`);
+		}
+
+		return parseCodexSse(response, signal);
+	}
+
+	throw new Error("Codex image generation request failed after all retries.");
+}
+
+// --- Extension entry point ---
+
+export default function codexImageGen(pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "codex_generate_image",
+		label: "Codex Image",
+		description:
+			"Generate an image with the OpenAI Codex ChatGPT backend built-in image_generation tool (gpt-image-2). Uses the existing openai-codex login; does not require OPENAI_API_KEY.",
+		promptSnippet: "Generate bitmap images via the OpenAI Codex ChatGPT backend gpt-image-2 image_generation tool.",
+		promptGuidelines: [
+			"Use codex_generate_image when the user asks to generate a raster image, illustration, photo, sprite, icon draft, banner, or other bitmap asset with OpenAI/Codex image generation.",
+			"Do not use codex_generate_image without a clear image-generation request, because it consumes the user's Codex image quota.",
+		],
+		parameters: TOOL_PARAMS,
+		executionMode: "parallel", // #4: safe to run concurrently — no shared state, saves serialized per-path
+		async execute(toolCallId, params: ToolParams, signal, onUpdate, ctx) {
+			const outputFormat = params.outputFormat || "png";
+			const config = loadConfig(ctx.cwd); // #5: load once, pass to resolveSaveConfig
+			const requestedModel = params.model || config.model || DEFAULT_MODEL;
+			const model = ctx.modelRegistry.find(PROVIDER, requestedModel)?.id || requestedModel; // #6: removed dead FALLBACK_MODEL
+			const token = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER);
+			if (!token) {
+				throw new Error(`Missing ${PROVIDER} credentials. Run /login and select ChatGPT Plus/Pro (Codex).`);
+			}
+			const accountId = extractChatGptAccountId(token);
+			const sessionId = ctx.sessionManager.getSessionId();
+
+			onUpdate?.({
+				content: [{ type: "text", text: `Requesting gpt-image-2 generation through ${PROVIDER}/${model}...` }],
+				details: { provider: PROVIDER, model, outputFormat },
+			});
+
+			const parsed = await requestImage(params, token, accountId, model, outputFormat, sessionId, signal);
+			if (!parsed.image) {
+				const text = parsed.text.join("").trim();
+				throw new Error(text ? `Codex did not return an image. Response text: ${text}` : "Codex did not return an image.");
+			}
+
+			const saveConfig = resolveSaveConfig(params, ctx.cwd, sessionId, config);
+			let savedPath: string | undefined;
+			if (saveConfig.mode !== "none" && saveConfig.outputDir) {
+				savedPath = await saveImage(parsed.image.result, outputFormat, saveConfig.outputDir, parsed.image.id || toolCallId);
+				// #12: second onUpdate after save with path + byte count
+				onUpdate?.({
+					content: [{ type: "text", text: `Image saved to ${savedPath}.` }],
+					details: {
+						provider: PROVIDER,
+						model,
+						savedPath,
+						byteCount: Buffer.byteLength(parsed.image.result, "base64"),
+					},
+				});
+			}
+
+			const summary = [
+				`Generated image via ${PROVIDER}/${model} using backend gpt-image-2.`,
+				`Status: ${parsed.image.status}.`,
+				parsed.image.revisedPrompt ? `Revised prompt: ${parsed.image.revisedPrompt}` : undefined,
+				savedPath ? `Saved image to: ${savedPath}` : "Image was not saved to disk.",
+			]
+				.filter(Boolean)
+				.join(" ");
+
+			return {
+				content: [
+					{ type: "text", text: summary },
+					{ type: "image", data: parsed.image.result, mimeType: mimeForFormat(outputFormat) },
+				],
+				details: {
+					provider: PROVIDER,
+					model,
+					backendImageModel: "gpt-image-2",
+					outputFormat,
+					saveMode: saveConfig.mode,
+					savedPath,
+					responseId: parsed.responseId,
+					imageGenerationId: parsed.image.id,
+					revisedPrompt: parsed.image.revisedPrompt,
+					usage: parsed.usage,
+				},
+			};
+		},
+	});
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "pi-codex-image-gen",
+  "version": "0.1.0",
+  "description": "Image generation for Pi using the ChatGPT Images 2.0 model.",
+  "license": "Apache-2.0",
+  "files": ["extensions", "skills", "README.md", "LICENSE"],
+  "keywords": ["pi-package", "pi", "codex", "image-generation", "gpt-image-2"],
+  "type": "module",
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "^0.70.2",
+    "@mariozechner/pi-coding-agent": "^0.70.2",
+    "typebox": "^1.1.33"
+  },
+  "pi": {
+    "extensions": ["./extensions"],
+    "skills": ["./skills"]
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.3"
+  }
+}

package/skills/imagegen/LICENSE.txt

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf of
+   any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don\'t include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.