diff --git a/packages/ai/README.md b/packages/ai/README.md index b9139bc3af20..e78dee015334 100644 --- a/packages/ai/README.md +++ b/packages/ai/README.md @@ -1,6 +1,6 @@ # @opencode-ai/ai -Schema-first LLM core for opencode. One typed request, response, event, and tool language; provider quirks live in adapters, not in calling code. +Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code. ```ts import { Effect } from "effect" @@ -24,6 +24,45 @@ const program = Effect.gen(function* () { Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment. +## Image generation + +Use `Image.generate` with an image model for direct asset generation: + +```ts +import { Image } from "@opencode-ai/ai" +import { OpenAI } from "@opencode-ai/ai/providers" + +const program = Effect.gen(function* () { + const response = yield* Image.generate({ + model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).image("gpt-image-2"), + prompt: "A robot tending a rooftop garden", + count: 2, + size: { width: 1024, height: 1024 }, + providerOptions: { openai: { quality: "high", outputFormat: "webp" } }, + }) + + return response.images // GeneratedImage[] with owned bytes or a provider URL +}) +``` + +Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool: + +```ts +const program = Effect.gen(function* () { + const response = yield* LLM.generate( + LLM.request({ + model: OpenAI.configure({ apiKey }).responses("gpt-5"), + prompt: "Design a solarpunk rooftop garden, then show me.", + tools: [OpenAI.imageGeneration({ quality: "high" })], + }), + ) + + return response.message +}) +``` + +The hosted result is represented as a provider-executed tool call and tool result. Its image is a `file` content item with a data URI, so retaining `response.message` preserves the generated image for continuation. + ## Public API - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes. @@ -32,6 +71,8 @@ Run `LLMClient.stream(request)` instead of `generate` when you want incremental - **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model. - **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing. - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams. +- **`Image.generate({...})`** — generate images through a provider-neutral image request and response model. +- **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`. ## Caching @@ -182,7 +223,7 @@ Adding a new model or deployment is usually 5-15 lines using `Route.make({ proto ## Effect -This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for runtime dispatch and import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough. +This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for LLM dispatch and `ImageClient.layer` for image dispatch, then import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough. ## See also diff --git a/packages/ai/src/image-client.ts b/packages/ai/src/image-client.ts new file mode 100644 index 000000000000..f6d85dd09758 --- /dev/null +++ b/packages/ai/src/image-client.ts @@ -0,0 +1,34 @@ +import { Context, Effect, Layer } from "effect" +import { RequestExecutor } from "./route/executor" +import type { ImageRequest, ImageResponse } from "./image" +import type { LLMError } from "./schema" + +export type Execute = RequestExecutor.Interface["execute"] + +export interface Interface { + readonly generate: (request: ImageRequest) => Effect.Effect +} + +export class Service extends Context.Service()("@opencode/ImageClient") {} + +export const generate = (request: ImageRequest): Effect.Effect => + Effect.gen(function* () { + const client = yield* Service + return yield* client.generate(request) + }) as Effect.Effect + +export const layer: Layer.Layer = Layer.effect( + Service, + Effect.gen(function* () { + const executor = yield* RequestExecutor.Service + return Service.of({ + generate: (request) => request.model.route.generate(request, executor.execute), + }) + }), +) + +export const ImageClient = { + Service, + layer, + generate, +} as const diff --git a/packages/ai/src/image.ts b/packages/ai/src/image.ts new file mode 100644 index 000000000000..fe850d9ede17 --- /dev/null +++ b/packages/ai/src/image.ts @@ -0,0 +1,116 @@ +import { Effect, Schema } from "effect" +import { HttpOptions, InvalidRequestReason, LLMError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema" +import { ImageClient, type Execute as ImageExecute } from "./image-client" + +export interface ImageRoute { + readonly id: string + readonly generate: (request: ImageRequest, execute: ImageExecute) => Effect.Effect +} + +export class ImageModel { + readonly id: ModelID + readonly provider: ProviderID + readonly route: ImageRoute + readonly defaults?: ImageModelDefaults + + constructor(input: ImageModel.Input) { + this.id = input.id + this.provider = input.provider + this.route = input.route + this.defaults = input.defaults + } + + static make(input: ImageModel.MakeInput) { + return new ImageModel({ + id: ModelID.make(input.id), + provider: ProviderID.make(input.provider), + route: input.route, + defaults: input.defaults, + }) + } +} + +export namespace ImageModel { + export interface Input { + readonly id: ModelID + readonly provider: ProviderID + readonly route: ImageRoute + readonly defaults?: ImageModelDefaults + } + + export interface MakeInput extends Omit { + readonly id: string | ModelID + readonly provider: string | ProviderID + } +} + +export interface ImageModelDefaults { + readonly providerOptions?: Record> + readonly http?: HttpOptions +} + +export const ImageModelSchema = Schema.declare((value): value is ImageModel => value instanceof ImageModel, { + expected: "Image.Model", +}) + +export const ImageSize = Schema.Struct({ + width: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)), + height: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)), +}).annotate({ identifier: "Image.Size" }) +export type ImageSize = Schema.Schema.Type + +export class ImageRequest extends Schema.Class("Image.Request")({ + model: ImageModelSchema, + prompt: Schema.String, + count: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))), + size: Schema.optional(ImageSize), + aspectRatio: Schema.optional(Schema.String), + seed: Schema.optional(Schema.Number), + providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))), + http: Schema.optional(HttpOptions), + metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)), +}) {} + +export type ImageRequestInput = Omit[0], "http"> & { + readonly http?: HttpOptions.Input +} + +export class GeneratedImage extends Schema.Class("Image.Generated")({ + mediaType: Schema.String, + data: Schema.Union([Schema.String, Schema.Uint8Array]), + providerMetadata: Schema.optional(ProviderMetadata), +}) {} + +export class ImageResponse extends Schema.Class("Image.Response")({ + images: Schema.Array(GeneratedImage), + usage: Schema.optional(Usage), + providerMetadata: Schema.optional(ProviderMetadata), +}) { + get image() { + return this.images[0] + } +} + +export const request = (input: ImageRequest | ImageRequestInput) => { + if (input instanceof ImageRequest) return input + return new ImageRequest({ + ...input, + http: input.http === undefined ? undefined : HttpOptions.make(input.http), + }) +} + +export const generate = (input: ImageRequest | ImageRequestInput) => + Effect.try({ + try: () => request(input), + catch: (error) => + new LLMError({ + module: "Image", + method: "generate", + reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }), + }), + }).pipe(Effect.flatMap(ImageClient.generate)) + +export const Image = { + request, + generate, +} as const diff --git a/packages/ai/src/index.ts b/packages/ai/src/index.ts index 273861b26fcb..46433c7ad11e 100644 --- a/packages/ai/src/index.ts +++ b/packages/ai/src/index.ts @@ -1,4 +1,5 @@ export { LLMClient } from "./route/client" +export { ImageClient } from "./image-client" export { Auth } from "./route/auth" export { Provider } from "./provider" export { ProviderPackage } from "./provider-package" @@ -10,6 +11,9 @@ export type { Service as LLMClientService, } from "./route/client" export * from "./schema" +export { GeneratedImage, ImageModel, ImageRequest, ImageResponse, ImageSize } from "./image" +export type { ImageModelDefaults, ImageRequestInput, ImageRoute } from "./image" +export { Image } from "./image" export { Tool, ToolFailure, toDefinitions } from "./tool" export { ToolRuntime } from "./tool-runtime" export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime" diff --git a/packages/ai/src/protocols/index.ts b/packages/ai/src/protocols/index.ts index d00d517a0907..bd3ee8eeec1d 100644 --- a/packages/ai/src/protocols/index.ts +++ b/packages/ai/src/protocols/index.ts @@ -2,6 +2,7 @@ export * as AnthropicMessages from "./anthropic-messages" export * as BedrockConverse from "./bedrock-converse" export * as Gemini from "./gemini" export * as OpenAIChat from "./openai-chat" +export * as OpenAIImages from "./openai-images" export * as OpenAICompatibleChat from "./openai-compatible-chat" export * as OpenAICompatibleResponses from "./openai-compatible-responses" export * as OpenAIResponses from "./openai-responses" diff --git a/packages/ai/src/protocols/openai-images.ts b/packages/ai/src/protocols/openai-images.ts new file mode 100644 index 000000000000..78ea527bd3df --- /dev/null +++ b/packages/ai/src/protocols/openai-images.ts @@ -0,0 +1,208 @@ +import { Effect, Encoding, Schema } from "effect" +import { Headers, HttpClientRequest } from "effect/unstable/http" +import { + ImageModel, + GeneratedImage, + ImageResponse, + type ImageRequest, + type ImageModelDefaults, + type ImageRoute, +} from "../image" +import { Auth, type Definition as AuthDefinition } from "../route/auth" +import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema" +import { ProviderShared } from "./shared" +import { OpenAIImage } from "./utils/openai-image" + +const ADAPTER = "openai-images" +export const DEFAULT_BASE_URL = "https://api.openai.com/v1" +export const PATH = "/images/generations" + +export interface OpenAIImageOptions { + readonly quality?: "auto" | "low" | "medium" | "high" + readonly background?: "auto" | "opaque" | "transparent" + readonly moderation?: "auto" | "low" + readonly outputFormat?: "png" | "jpeg" | "webp" + readonly outputCompression?: number +} + +const OpenAIImageBody = Schema.Struct({ + model: Schema.String, + prompt: Schema.String, + n: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))), + size: Schema.optional(Schema.String), + quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])), + background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])), + moderation: Schema.optional(Schema.Literals(["auto", "low"])), + output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])), + output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))), +}) +export type OpenAIImageBody = Schema.Schema.Type + +const OpenAIImageResponse = Schema.Struct({ + data: Schema.Array( + Schema.Struct({ + b64_json: Schema.optional(Schema.String), + url: Schema.optional(Schema.String), + revised_prompt: Schema.optional(Schema.String), + }), + ), + output_format: Schema.optional(Schema.String), + usage: Schema.optional( + Schema.Struct({ + input_tokens: Schema.optional(Schema.Number), + output_tokens: Schema.optional(Schema.Number), + total_tokens: Schema.optional(Schema.Number), + input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)), + output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)), + }), + ), +}) + +export interface ModelInput { + readonly id: string + readonly auth: AuthDefinition + readonly baseURL?: string + readonly headers?: Record + readonly defaults?: ImageModelDefaults +} + +const providerOptions = (request: ImageRequest): OpenAIImageOptions => ({ + ...request.model.defaults?.providerOptions?.openai, + ...request.providerOptions?.openai, +}) + +const body = (request: ImageRequest): OpenAIImageBody => { + const options = providerOptions(request) + return { + model: request.model.id, + prompt: request.prompt, + n: request.count, + size: request.size === undefined ? undefined : `${request.size.width}x${request.size.height}`, + quality: options.quality, + background: options.background, + moderation: options.moderation, + output_format: options.outputFormat, + output_compression: options.outputCompression, + } +} + +const invalidOutput = (message: string) => + new LLMError({ + module: ADAPTER, + method: "generate", + reason: new InvalidProviderOutputReason({ message, route: ADAPTER }), + }) + +const applyQuery = (url: string, query: Record | undefined) => { + if (!query) return url + const next = new URL(url) + Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value)) + return next.toString() +} + +const PROTOCOL_BODY_FIELDS = new Set([ + "model", + "prompt", + "n", + "size", + "quality", + "background", + "moderation", + "output_format", + "output_compression", +]) + +const bodyWithOverlay = Effect.fn("OpenAIImages.bodyWithOverlay")(function* ( + imageBody: OpenAIImageBody, + overlay: Record | undefined, +) { + if (!overlay) return imageBody + const reserved = Object.keys(overlay).filter((key) => PROTOCOL_BODY_FIELDS.has(key)) + if (reserved.length > 0) + return yield* ProviderShared.invalidRequest( + `http.body cannot overlay protocol-owned field(s): ${reserved.join(", ")}`, + ) + return mergeJsonRecords(imageBody, overlay) ?? imageBody +}) + +export const model = (input: ModelInput) => { + const route: ImageRoute = { + id: ADAPTER, + generate: Effect.fn("OpenAIImages.generate")(function* (request: ImageRequest, execute) { + if (request.aspectRatio !== undefined) + return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common aspectRatio option") + if (request.seed !== undefined) + return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common seed option") + + const requestBody = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIImageBody))(body(request)) + const http = mergeHttpOptions(request.model.defaults?.http, request.http) + const overlaidBody = yield* bodyWithOverlay(requestBody, http?.body) + const text = ProviderShared.encodeJson(overlaidBody) + const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query) + const headers = yield* Auth.toEffect(input.auth)({ + request, + method: "POST", + url, + body: text, + headers: Headers.fromInput({ ...input.headers, ...http?.headers }), + }) + const response = yield* execute( + HttpClientRequest.post(url).pipe( + HttpClientRequest.setHeaders(headers), + HttpClientRequest.bodyText(text, "application/json"), + ), + ) + const payload = yield* response.json.pipe( + Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")), + ) + const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe( + Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")), + ) + const format = decoded.output_format ?? providerOptions(request).outputFormat ?? "png" + const images = yield* Effect.forEach(decoded.data, (item, index) => { + if (item.b64_json) + return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe( + Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)), + Effect.map( + (data) => + new GeneratedImage({ + mediaType: `image/${format}`, + data, + providerMetadata: + item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } }, + }), + ), + ) + if (item.url) + return Effect.succeed( + new GeneratedImage({ + mediaType: `image/${format}`, + data: item.url, + providerMetadata: + item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } }, + }), + ) + return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`)) + }) + if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images") + return new ImageResponse({ + images, + usage: + decoded.usage === undefined + ? undefined + : new Usage({ + inputTokens: decoded.usage.input_tokens, + outputTokens: decoded.usage.output_tokens, + totalTokens: decoded.usage.total_tokens, + providerMetadata: { openai: decoded.usage }, + }), + providerMetadata: { openai: { outputFormat: format } }, + }) + }), + } + return ImageModel.make({ id: input.id, provider: "openai", route, defaults: input.defaults }) +} + +export const OpenAIImages = { + model, +} as const diff --git a/packages/ai/src/protocols/openai-responses.ts b/packages/ai/src/protocols/openai-responses.ts index 65eb7e6c1a23..f8e11b3cc2a1 100644 --- a/packages/ai/src/protocols/openai-responses.ts +++ b/packages/ai/src/protocols/openai-responses.ts @@ -1,4 +1,4 @@ -import { Effect, Schema } from "effect" +import { Effect, Encoding, Schema } from "effect" import { Route } from "../route/client" import { Auth } from "../route/auth" import { Endpoint } from "../route/endpoint" @@ -25,6 +25,7 @@ import { OpenAIOptions } from "./utils/openai-options" import { Lifecycle } from "./utils/lifecycle" import { ToolSchemaProjection } from "./utils/tool-schema" import { ToolStream } from "./utils/tool-stream" +import { OpenAIImage } from "./utils/openai-image" const ADAPTER = "openai-responses" export const DEFAULT_BASE_URL = "https://api.openai.com/v1" @@ -113,11 +114,24 @@ const OpenAIResponsesTool = Schema.Struct({ parameters: JsonObject, strict: Schema.optional(Schema.Boolean), }) -type OpenAIResponsesTool = Schema.Schema.Type +const OpenAIResponsesImageGenerationTool = Schema.Struct({ + type: Schema.tag("image_generation"), + action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])), + background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])), + input_fidelity: Schema.optional(Schema.Literals(["low", "high"])), + output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))), + output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])), + partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))), + quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])), + size: Schema.optional(OpenAIImage.Size), +}) +const OpenAIResponsesTools = Schema.Union([OpenAIResponsesTool, OpenAIResponsesImageGenerationTool]) +type OpenAIResponsesTool = Schema.Schema.Type const OpenAIResponsesToolChoice = Schema.Union([ Schema.Literals(["auto", "none", "required"]), Schema.Struct({ type: Schema.tag("function"), name: Schema.String }), + Schema.Struct({ type: Schema.tag("image_generation") }), ]) // Fields shared between the HTTP body and the WebSocket `response.create` @@ -128,7 +142,7 @@ const OpenAIResponsesCoreFields = { model: Schema.String, input: Schema.Array(OpenAIResponsesInputItem), instructions: Schema.optional(Schema.String), - tools: optionalArray(OpenAIResponsesTool), + tools: optionalArray(OpenAIResponsesTools), tool_choice: Schema.optional(OpenAIResponsesToolChoice), store: Schema.optional(Schema.Boolean), service_tier: Schema.optional(OpenAIOptions.OpenAIServiceTier), @@ -194,6 +208,8 @@ const OpenAIResponsesStreamItem = Schema.Struct({ outputs: Schema.optional(Schema.Unknown), server_label: Schema.optional(Schema.String), output: Schema.optional(Schema.Unknown), + result: Schema.optional(Schema.String), + output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])), error: Schema.optional(Schema.Unknown), encrypted_content: optionalNull(Schema.String), }) @@ -258,21 +274,41 @@ const invalid = ProviderShared.invalidRequest // ============================================================================= // Request Lowering // ============================================================================= -const lowerTool = (tool: ToolDefinition, inputSchema: JsonSchema): OpenAIResponsesTool => ({ - type: "function", - name: tool.name, - description: tool.description, - parameters: ToolSchemaProjection.openAI(inputSchema), - // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas. - strict: false, +const nativeImageToolInput = (tool: ToolDefinition) => { + const native = tool.native?.openai + return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined +} + +const nativeImageTool = (tool: ToolDefinition) => { + const native = nativeImageToolInput(tool) + return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined +} + +const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDefinition, inputSchema: JsonSchema) { + const native = nativeImageToolInput(tool) + if (native !== undefined) { + if (Schema.is(OpenAIResponsesImageGenerationTool)(native)) return native + return yield* invalid("OpenAI Responses image generation tool options are invalid") + } + return { + type: "function" as const, + name: tool.name, + description: tool.description, + parameters: ToolSchemaProjection.openAI(inputSchema), + // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas. + strict: false, + } }) -const lowerToolChoice = (toolChoice: NonNullable) => +const lowerToolChoice = (toolChoice: NonNullable, tools: ReadonlyArray) => ProviderShared.matchToolChoice("OpenAI Responses", toolChoice, { auto: () => "auto" as const, none: () => "none" as const, required: () => "required" as const, - tool: (name) => ({ type: "function" as const, name }), + tool: (name) => + tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined) + ? ({ type: "image_generation" } as const) + : { type: "function" as const, name }, }) const lowerToolCall = (part: ToolCallPart): OpenAIResponsesInputItem => ({ @@ -420,6 +456,13 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ const itemID = hostedToolItemID(part) if (store !== false && itemID && !hostedToolReferences.has(itemID)) input.push({ type: "item_reference", id: itemID }) + if (store === false && part.name === "image_generation" && part.result.type === "content") { + const content: ReadonlyArray = part.result.value + input.push({ + role: "user", + content: yield* Effect.forEach(content, lowerToolResultContentItem), + }) + } if (itemID) hostedToolReferences.add(itemID) continue } @@ -485,10 +528,10 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: tools: request.tools.length === 0 ? undefined - : request.tools.map((tool) => + : yield* Effect.forEach(request.tools, (tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)), ), - tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined, + tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined, stream: true as const, max_output_tokens: generation?.maxTokens, temperature: generation?.temperature, @@ -574,14 +617,29 @@ const isReasoningItem = ( // Round-trip the full item as the structured result so consumers can extract // outputs / sources / status without re-decoding. -const hostedToolResult = (item: OpenAIResponsesStreamItem) => { +const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item: OpenAIResponsesStreamItem) { const isError = typeof item.error !== "undefined" && item.error !== null + if (item.type === "image_generation_call" && item.result) { + yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe( + Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")), + ) + return { + type: "content" as const, + value: [ + { + type: "file" as const, + uri: `data:image/${item.output_format ?? "png"};base64,${item.result}`, + mime: `image/${item.output_format ?? "png"}`, + }, + ], + } + } return isError ? { type: "error" as const, value: item.error } : { type: "json" as const, value: item } -} +}) -const hostedToolEvents = ( +const hostedToolEvents = Effect.fn("OpenAIResponses.hostedToolEvents")(function* ( item: OpenAIResponsesStreamItem & { type: HostedToolType; id: string }, -): ReadonlyArray => { +) { const tool = HOSTED_TOOLS[item.type] const providerMetadata = openaiMetadata({ itemId: item.id }) return [ @@ -595,12 +653,12 @@ const hostedToolEvents = ( LLMEvent.toolResult({ id: item.id, name: tool.name, - result: hostedToolResult(item), + result: yield* hostedToolResult(item), providerExecuted: true, providerMetadata, }), ] -} +}) type StepResult = readonly [ParserState, ReadonlyArray] @@ -847,7 +905,7 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function* if (isHostedToolItem(item)) { const events: LLMEvent[] = [] const lifecycle = Lifecycle.stepStart(state.lifecycle, events) - events.push(...hostedToolEvents(item)) + events.push(...(yield* hostedToolEvents(item))) return [{ ...state, lifecycle }, events] satisfies StepResult } diff --git a/packages/ai/src/protocols/utils/openai-image.ts b/packages/ai/src/protocols/utils/openai-image.ts new file mode 100644 index 000000000000..765c99ce166c --- /dev/null +++ b/packages/ai/src/protocols/utils/openai-image.ts @@ -0,0 +1,20 @@ +import { Schema } from "effect" + +const dimensions = (value: string) => { + const match = /^(\d+)x(\d+)$/.exec(value) + if (!match) return undefined + return { width: Number(match[1]), height: Number(match[2]) } +} + +export const Size = Schema.String.check( + Schema.makeFilter((value) => { + if (value === "auto") return undefined + const parsed = dimensions(value) + if (!parsed) return "image size must be `auto` or `{width}x{height}`" + return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers" + }), +) + +export const OpenAIImage = { + Size, +} as const diff --git a/packages/ai/src/providers/openai.ts b/packages/ai/src/providers/openai.ts index 73819eaf471c..9885be27e4c2 100644 --- a/packages/ai/src/providers/openai.ts +++ b/packages/ai/src/providers/openai.ts @@ -1,12 +1,14 @@ import { AuthOptions, type ProviderAuthOption } from "../route/auth-options" import type { Route, RouteDefaultsInput } from "../route/client" import type { ProviderPackage } from "../provider-package" -import { ProviderID, type ModelID } from "../schema" +import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema" import * as OpenAIChat from "../protocols/openai-chat" import * as OpenAIResponses from "../protocols/openai-responses" import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options" +import { OpenAIImages, type OpenAIImageOptions } from "../protocols/openai-images" export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options" +export type { OpenAIImageOptions } from "../protocols/openai-images" export const id = ProviderID.make("openai") @@ -20,8 +22,44 @@ export type Config = RouteDefaultsInput & readonly baseURL?: string readonly queryParams?: Record readonly providerOptions?: OpenAIProviderOptionsInput + readonly image?: ImageConfig } +export interface ImageConfig { + readonly providerOptions?: OpenAIImageOptions +} + +export interface ImageGenerationOptions { + readonly action?: "auto" | "generate" | "edit" + readonly background?: "auto" | "opaque" | "transparent" + readonly inputFidelity?: "low" | "high" + readonly outputCompression?: number + readonly outputFormat?: "png" | "jpeg" | "webp" + readonly partialImages?: number + readonly quality?: "auto" | "low" | "medium" | "high" + readonly size?: string +} + +export const imageGeneration = (options: ImageGenerationOptions = {}) => + ToolDefinition.make({ + name: "image_generation", + description: "Generate or edit an image using OpenAI's hosted image generation tool.", + inputSchema: { type: "object", properties: {}, additionalProperties: false }, + native: { + openai: { + type: "image_generation", + action: options.action, + background: options.background, + input_fidelity: options.inputFidelity, + output_compression: options.outputCompression, + output_format: options.outputFormat, + partial_images: options.partialImages, + quality: options.quality, + size: options.size, + }, + }, + }) + export interface Settings extends ProviderPackage.Settings { readonly apiKey?: string readonly baseURL?: string @@ -35,7 +73,7 @@ export interface Settings extends ProviderPackage.Settings { const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY") const defaults = (input: Config) => { - const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, ...rest } = input + const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, image: _image, ...rest } = input return rest } @@ -55,6 +93,21 @@ export const configure = (input: Config = {}) => { const responsesWebSocket = (id: string | ModelID) => responsesWebSocketRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id }) const chat = (id: string | ModelID) => chatRoute.with(withOpenAIOptions(id, modelDefaults)).model({ id }) + const image = (modelID: string | ModelID) => + OpenAIImages.model({ + id: modelID, + auth: auth(input), + baseURL: input.baseURL, + headers: input.headers, + defaults: { + providerOptions: + input.image?.providerOptions === undefined ? undefined : { openai: { ...input.image.providerOptions } }, + http: mergeHttpOptions( + input.http === undefined ? undefined : HttpOptions.make(input.http), + input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams }), + ), + }, + }) return { id, @@ -62,6 +115,7 @@ export const configure = (input: Config = {}) => { responses, responsesWebSocket, chat, + image, configure, } } @@ -97,3 +151,4 @@ export const chatModel: ProviderPackage.Definition["model"] = (modelID export const responses = provider.responses export const responsesWebSocket = provider.responsesWebSocket export const chat = provider.chat +export const image = provider.image diff --git a/packages/ai/src/route/auth.ts b/packages/ai/src/route/auth.ts index 9bbbb2b84caa..6dc87d3a91f1 100644 --- a/packages/ai/src/route/auth.ts +++ b/packages/ai/src/route/auth.ts @@ -1,6 +1,6 @@ import { Config, Effect, Redacted } from "effect" import { Headers } from "effect/unstable/http" -import { AuthenticationReason, InvalidRequestReason, LLMError, type LLMRequest } from "../schema" +import { AuthenticationReason, InvalidRequestReason, LLMError, type HttpOptions } from "../schema" export class MissingCredentialError extends Error { readonly _tag = "MissingCredentialError" @@ -15,7 +15,7 @@ export type AuthError = CredentialError | LLMError type Secret = string | Redacted.Redacted | Config.Config export interface AuthInput { - readonly request: LLMRequest + readonly request: { readonly http?: HttpOptions } readonly method: "POST" | "GET" readonly url: string readonly body: string diff --git a/packages/ai/test/fixtures/recordings/openai-images/generates-an-image.json b/packages/ai/test/fixtures/recordings/openai-images/generates-an-image.json new file mode 100644 index 000000000000..41bf97ed4baf --- /dev/null +++ b/packages/ai/test/fixtures/recordings/openai-images/generates-an-image.json @@ -0,0 +1,32 @@ +{ + "version": 1, + "metadata": { + "tags": [ + "prefix:openai-images", + "provider:openai", + "protocol:openai-images" + ], + "name": "openai-images/generates-an-image", + "recordedAt": "2026-07-19T14:41:43.188Z" + }, + "interactions": [ + { + "transport": "http", + "request": { + "method": "POST", + "url": "https://api.openai.com/v1/images/generations", + "headers": { + "content-type": "application/json" + }, + "body": "{\"model\":\"gpt-image-1-mini\",\"prompt\":\"A simple flat black circle centered on a plain white background.\",\"size\":\"1024x1024\",\"quality\":\"low\",\"output_format\":\"jpeg\",\"output_compression\":10}" + }, + "response": { + "status": 200, + "headers": { + "content-type": "application/json" + }, + "body": "{\n \"created\": 1784472103,\n \"background\": \"opaque\",\n \"data\": [\n {\n \"b64_json\": \"/9j/4AAQSkZJRgABAQAAAQABAAD/63FxSlACEQAAAAEAAHFnanVtYgAAAB5qdW1kYzJwYQARABCAAACqADibcQNjMnBhAAAAcUFqdW1iAAAAR2p1bWRjMm1hABEAEIAAAKoAOJtxA3VybjpjMnBhOjg1MzZkMmU1LWI5OTgtNDgwMi1iYTIyLWM5MmU2MWYyMWM4ZAAAACEcanVtYgAAAClqdW1kYzJhcwARABCAAACqADibcQNjMnBhLmFzc2VydGlvbnMAAAAJ0Wp1bWIAAAA7anVtZEDLDDK7ikidpwsq1vR/Q2kTYzJwYS5pY29uAAAAABhjMnNosbfWxozdajRf38VdnN0JzAAAABdiZmRiAGltYWdlL3N2Zyt4bWwAAAAJd2JpZGI8c3ZnIHdpZHRoPSI3MTYiIGhlaWdodD0iNzE2IiB2aWV3Qm94PSIwIDAgNzE2IDcxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTUwOC43NDkgMzE3LjM5OUM1MTYuNzc3IDI4Ny4zMTQgNTA4Ljk5MSAyNTMuODg0IDQ4NS4zODkgMjMwLjI4MkM0NjEuNzg4IDIwNi42ODEgNDI4LjM2IDE5OC44OTUgMzk4LjI3MyAyMDYuOTIzQzM3Ni4yMzEgMTg0LjkyOCAzNDMuMzkgMTc0Ljk1NiAzMTEuMTQ4IDE4My41OTZDMjc4LjkwNiAxOTIuMjM0IDI1NS40NSAyMTcuMjkyIDI0Ny4zNiAyNDcuMzYxQzIxNy4yOTEgMjU1LjQ1MSAxOTIuMjMzIDI3OC45MSAxODMuNTk1IDMxMS4xNDlDMTc0Ljk1NyAzNDMuMzkxIDE4NC45MjcgMzc2LjIzMiAyMDYuOTI0IDM5OC4yNzRDMTk4Ljg5NiA0MjguMzU5IDIwNi42ODMgNDYxLjc4OSAyMzAuMjg0IDQ4NS4zOTFDMjUzLjg4NSA1MDguOTkyIDI4Ny4zMTMgNTE2Ljc3OSAzMTcuNDAxIDUwOC43NUMzMzkuNDQyIDUzMC43NDUgMzcyLjI4NiA1NDAuNzE3IDQwNC41MjUgNTMyLjA3OUM0MzYuNzY3IDUyMy40NDEgNDYwLjIyMyA0OTguMzg0IDQ2OC4zMTMgNDY4LjMxNUM0OTguMzgzIDQ2MC4yMjQgNTIzLjQ0IDQzNi43NjYgNTMyLjA3OCA0MDQuNTI2QzU0MC43MTYgMzcyLjI4NSA1MzAuNzQ3IDMzOS40NDMgNTA4Ljc0OSAzMTcuNDAyVjMxNy4zOTlaTTQ3MC44OTkgMjQ0Ljc3NkM0ODYuODkyIDI2MC43NyA0OTMuNDg4IDI4Mi42MDEgNDkwLjY4NyAzMDMuNDEyTDQxNS41NzcgMjYwLjA0NkM0MTIuNDExIDI1OC4yMTggNDA4LjUwOSAyNTguMjE4IDQwNS4zNDUgMjYwLjA0NkwzMTcuNDAxIDMxMC44MlYyNzcuNTI2QzMxNy40MDEgMjc1LjE5MSAzMTguNjUyIDI3My4wMDUgMzIwLjY3NiAyNzEuODM3TDM4Ny42NDQgMjMzLjE3NEM0MTQuMTc4IDIxOC4zNTMgNDQ4LjM0NiAyMjIuMjIzIDQ3MC45MDEgMjQ0Ljc3Nkg0NzAuODk5Wk0zNTcuODM3IDMxMS4xNDRMMzk4LjI3NSAzMzQuNDkxVjM4MS4xODVMMzU3LjgzNyA0MDQuNTMyTDMxNy4zOTggMzgxLjE4NVYzMzQuNDkxTDM1Ny44MzcgMzExLjE0NFpNMjY0Ljc3NiAyNjkuNjkzQzI2NS4yMDcgMjM5LjMwNSAyODUuNjQ0IDIxMS42NDkgMzE2LjQ1MyAyMDMuMzkzQzMzOC4zIDE5Ny41NCAzNjAuNTA1IDIwMi43NDQgMzc3LjEyNyAyMTUuNTczTDMwMi4wMTQgMjU4LjkzN0MyOTguODQ4IDI2MC43NjQgMjk2Ljg5OCAyNjQuMTQ0IDI5Ni44OTggMjY3Ljc5OFYzNjkuMzQ2TDI2OC4wNjUgMzUyLjY5OUMyNjYuMDQzIDM1MS41MzEgMjY0Ljc3NiAzNDkuMzUzIDI2NC43NzYgMzQ3LjAxN1YyNjkuNjkxVjI2OS42OTNaTTIwMy4zOTEgMzE2LjQ1NEMyMDkuMjQ0IDI5NC42MDggMjI0Ljg1NCAyNzcuOTc4IDI0NC4yNzYgMjY5Ljk5OVYzNTYuNzNDMjQ0LjI3NiAzNjAuMzg0IDI0Ni4yMjYgMzYzLjc2MyAyNDkuMzkyIDM2NS41OTFMMzM3LjMzNyA0MTYuMzY1TDMwOC41MDMgNDMzLjAxM0MzMDYuNDgxIDQzNC4xODEgMzAzLjk2MSA0MzQuMTg4IDMwMS45MzkgNDMzLjAyTDIzNC45NzEgMzk0LjM1N0MyMDguODY4IDM3OC43ODkgMTk1LjEzOCAzNDcuMjYxIDIwMy4zOTEgMzE2LjQ1NFpNMjQ0Ljc3NSA0NzAuOUMyMjguNzgxIDQ1NC45MDYgMjIyLjE4NiA0MzMuMDc1IDIyNC45ODYgNDEyLjI2NEwzMDAuMDk2IDQ1NS42M0MzMDMuMjYzIDQ1Ny40NTcgMzA3LjE2NCA0NTcuNDU3IDMxMC4zMjggNDU1LjYzTDM5OC4yNzMgNDA0Ljg1NlY0MzguMTQ5QzM5OC4yNzMgNDQwLjQ4NSAzOTcuMDIyIDQ0Mi42NzEgMzk0Ljk5NyA0NDMuODM5TDMyOC4wMjkgNDgyLjUwMkMzMDEuNDk1IDQ5Ny4zMjIgMjY3LjMyNyA0OTMuNDUyIDI0NC43NzIgNDcwLjlIMjQ0Ljc3NVpNNDUwLjg5NyA0NDUuOTgyQzQ1MC40NjYgNDc2LjM3MSA0MzAuMDI5IDUwNC4wMjcgMzk5LjIyIDUxMi4yODNDMzc3LjM3MyA1MTguMTM2IDM1NS4xNjggNTEyLjkzMiAzMzguNTQ3IDUwMC4xMDJMNDEzLjY1OSA0NTYuNzM4QzQxNi44MjYgNDU0LjkxMSA0MTguNzc1IDQ1MS41MzIgNDE4Ljc3NSA0NDcuODc3VjM0Ni4zMjlMNDQ3LjYwOSAzNjIuOTc3QzQ0OS42MzEgMzY0LjE0NSA0NTAuODk3IDM2Ni4zMjMgNDUwLjg5NyAzNjguNjU5VjQ0NS45ODVWNDQ1Ljk4MlpNNTEyLjI4MiAzOTkuMjIxQzUwNi40MjkgNDIxLjA2OCA0OTAuODE5IDQzNy42OTcgNDcxLjM5NyA0NDUuNjc2VjM1OC45NDZDNDcxLjM5NyAzNTUuMjkyIDQ2OS40NDggMzUxLjkxMiA0NjYuMjgxIDM1MC4wODVMMzc4LjMzNiAyOTkuMzExTDQwNy4xNyAyODIuNjYzQzQwOS4xOTIgMjgxLjQ5NSA0MTEuNzEyIDI4MS40ODcgNDEzLjczNCAyODIuNjU1TDQ4MC43MDIgMzIxLjMxOEM1MDYuODA1IDMzNi44ODcgNTIwLjUzNiAzNjguNDE1IDUxMi4yODIgMzk5LjIyMVoiIGZpbGw9ImJsYWNrIi8+Cjwvc3ZnPgoAAAFFanVtYgAAAEFqdW1kY2JvcgARABCAAACqADibcRNjMnBhLmFjdGlvbnMudjIAAAAAGGMyc2jTzBVj0c9qhdqI+zcNzNnPAAAA/GNib3KhZ2FjdGlvbnOCpGZhY3Rpb25sYzJwYS5jcmVhdGVkZHdoZW7AdDIwMjYtMDctMTlUMDA6MDA6MDBabXNvZnR3YXJlQWdlbnSiZG5hbWVpZ3B0LWltYWdlZ3ZlcnNpb25ncHJlLTIuMHFkaWdpdGFsU291cmNlVHlwZXhGaHR0cDovL2N2LmlwdGMub3JnL25ld3Njb2Rlcy9kaWdpdGFsc291cmNldHlwZS90cmFpbmVkQWxnb3JpdGhtaWNNZWRpYaJmYWN0aW9ubmMycGEuY29udmVydGVkZHdoZW7AdDIwMjYtMDctMTlUMDA6MDA6MDBaAAAVEmp1bWIAAABJanVtZGNib3IAEQAQgAAAqgA4m3ETYzJwYS5jZXJ0aWZpY2F0ZS1zdGF0dXMAAAAAGGMyc2hBaJ4w0oiVWAcVQa2bxYMgAAAUwWNib3KhaG9jc3BWYWxzgnkKdE1JSUgwd29CQUtDQ0I4d3dnZ2ZJQmdrckJnRUZCUWN3QVFFRWdnZTVNSUlIdFRDQjZhSVdCQlFjKzFlaXdCdEx4cmVlaTFWMWVqMVVmbVJEWFJnUE1qQXlOakEzTVRnd09UQXlNelJhTUlHWU1JR1ZNRWt3Q1FZRkt3NERBaG9GQUFRVTM0STNVMTVUMkRPeDRBUTlKRFh4ZGViaENoa0VGRGs5RUVmY2w0K3ZpSHROY3hnZHplWHVwS1VxQWhBTHBmenBEbkNNOGdXQU1lNUVIR1J6Z0FBWUR6SXdNall3TnpFNE1Ea3dNak0wV3FBUkdBOHlNREkyTURjeU5UQTVNREl6TTFxaElqQWdNQjRHQ1NzR0FRVUZCekFCQmdRUkdBOHlNREUyTURjeU1EQTVNREl6TkZxaEl6QWhNQjhHQ1NzR0FRVUZCekFCQWdRU0JCRFFoUFRtcS9zREs4K0VmNVV0QkNBRE1BMEdDU3FHU0liM0RRRUJDd1VBQTRJQmdRQkd0NVgzZ0hKaEhZVWRsYktHL2RsS0x0a1BCdkkzRE1CYnRTRmNvU0htWXAzU1N5S2E5MERLekwrdEk0aHd4aVpvY3pMTVRnT0tRT0FaS0loUkthRThNR3g5RXRrSzFBdWZIcWJhbHhocTlWbERpYmRwbmdKbnVBeHpCVTVEbE9qaXJMVFJUZnlnTkNyWlZoTm9TSDRUNzE4R0xrc0Z4NXBWWThaMUZYdVd2Q3phbXRnU0dnaXNLQjFUL0xpU1VieVdEL1hKYWplRDBpKzA0a1JFbXZoajBLcGt1N3pKK3ZkK2ErSU5ic1dBZ01lVzdUanU5VnFTUWUwdVcySEtoZCt3WEF3R3l3dEZXM1dEVTZ6Ukh6dkVSNUtRY0ZPcmU4VFQ3Z1ZUV1dubW4vbEVmRy9LaWhZOC9HbjhJazYxVXNROCtZZEJpK2MzbWs1ckRzVmJCWllJZ2dtVzF3dmFCQlVKTHhzTVlhbFFyd01JcG1JT2Zob3VZNFZzc3VndzdyWnRlb0oxa0xKUXdWQjRPOVhDQTN3ODA4KzI2ZVhISWFYNDl0WnlZd0Jhd1pBNjUzbWpBazBHemNkbGtMTXk3ZjUxVzZMN25ybXh4ZlBSa2lGRVV3T21EUk4xcUVpOUNjYWQ0YUIwczRtYktUR1dKODI4ekczRHR0MFY4WnFOMU15Z2dnVXhNSUlGTFRDQ0JTa3dnZ01Sb0FNQ0FRSUNFR055NnZkY0hFMnhKNlZmZDkyZmRoc3dEUVlKS29aSWh2Y05BUUVMQlFBd1NqRWhNQjhHQTFVRUF3d1lVMU5NTG1OdmJTQkRNbEJCSUVsRFFTQlNNU0F5TURJMU1SZ3dGZ1lEVlFRS0RBOVRVMHdnUTI5eWNHOXlZWFJwYjI0eEN6QUpCZ05WQkFZVEFsVlRNQjRYRFRJMk1ERXdNakl4TVRFMU5Wb1hEVEkzTURFd01qSXhNVEUxTkZvd1RURUxNQWtHQTFVRUJoTUNWVk14RVRBUEJnTlZCQW9NQ0ZOVGJDQkRiM0p3TVNzd0tRWURWUVFERENKVFUwd3VZMjl0SUVNeVVFRWdTVU5CSUZJeElFOURVMUFnVW1WemNHOXVaR1Z5TUlJQm9qQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FZOEFNSUlCaWdLQ0FZRUF6NEp2aXlOdDJhcVBaRTMyR0Y3LzRLcHhzcXlPSExMY3BhWEllR1FxbjVvMXJGZXJLSGJEMmx3SG5pYXlGTUxoYUVGMFVTQ1JTZUFZRXNnWThNWFYyM1Qwd2RSemZuZ1VQV2ZvSVR0b09pWW5IYVRrNllpbm50dFpZMGUvSnpmcVBnc1BUaUg4c3NMdnNpS0VZZmYzS3VPdDZRa1VJQ1pYWVdUemFvQ3NmbVU2cm5QZFROMm9hUmM3eFhkWTZkU3R5UFVGbnpTU1Q5MFZFcFIra0UySW9BSlBUNVQzMUhZbkdhWVlwdGpUb3lydDYyRGplVllKQVI5SmxLVmdjOHZDYkVIenozcDVsSzBSOVArUmVPZlRzMXR3Mi9LT2dkd0xpc3hINHFKS3ZCSU11cVZTVldWWlBhZUhnL1Y2dzFMOHpuWDA2SG5Fa1ZyMGM1VExkQnIrZllPTm55QWg5VWYrUTF2UERGNHRybnI2WFFMVVdjMnI1NmxMMk5VWmx3d3MwV01ZdmVvNkhOdjRWMThwV3RMTnJtUlFuc1AwZ0NMVGlxMml1NHR4bmVHNEpiUmVVblhsK3B3c0p3aTF3a3hjTzFETnJLMmdHRUtlZUpMZFpEc3RQclphT3BTSGNJMmFNeXZYN2dwUU15ekY0MjZ3a0Fvb2EzRmR4OVo1NE9ZbkFnTUJBQUdqZ1ljd2dZUXdEQVlEVlIwVEFRSC9CQUl3QURBZkJnTlZIU01FR0RBV2dCUTVQUkJIM0plUHI0aDdUWE1ZSGMzbDdxU2xLakFQQmdrckJnRUZCUWN3QVFVRUFnVUFNQk1HQTFVZEpRUU1NQW9HQ0NzR0FRVUZCd01KTUIwR0ExVWREZ1FXQkJRYysxZWl3QnRMeHJlZWkxVjFlajFVZm1SRFhUQU9CZ05WSFE4QkFmOEVCQU1DQjRBd0RRWUpLb1pJaHZjTkFRRUxCUUFEZ2dJQkFESGx0V3QvZGh2WHd0c3FmZWtmajY3Y215L3YzaDdtZ1hqbk5hYWhVbHNNYm10Y2kzUnBHU29BZ00yV2lPR0diYm5YVnFDVHFXOGludFJXVkNtVTJyOHlMTUtNNmlSVVh6UXExMU5td3I5SDl2L3NuWWRSbmpSQkQ4dGtEMEY0ZmpHc05oeUhUSFVieHBNWnhyUk5BZTBhaC9HQU5mdFFCNC9IVDFvViszRUp2cHBqL3N1SGZvWWhsajhLZ2N4WGgvQlVKbmJkcUtYc2NhMGRsd1E2TjVubzBhWFNJY0NUby90djNrbGsvZG0xV3JBc09yOC92bEtpR0NuVTdiQXVpaXdiU2lNeCtxZXdocmFJbGJEYWtEeDcwbVpCTEs1cUZVdks5MU1DUHBpOWZMTEV0ZWtITkw4VUs1WkpLNmxDTWQ4Vndza3RucFc5RG1XNitYc3llMWpCOGF0V0ppbFFlRHMzQ29RcVFvZmhidlBmZkxzTElGSmZnMzFFbmRqRnNrcTE1Um5RZ01NRThkbkhBWmdnWlpyL2tVZnlyY3Q1VDE5SlFXWEN2QXhQcTFkMGpWdkgySWtZaTZZTjRCcStPWkptejdQNG5OdHltOXdJcU9COC95RE5na1hqUzQ3eFFkaitxWVBTZ3B5U2FYMHVWbkJwaThtNDlITHQrUDBlNnp2TXlPcTFVazhJcVNPVFpTNkJXOTZUQWNVZDJGZVBRTWNpR2xEak9YcUgrc1RCL0NGTGh2eCt2NUxjVDRaamlnVzlYa05FaEZjeUFlRHVpTis0UWhoVHAzclg1UGpaV21tVm55L0V6TWR4R0U3WWo2MVhYUnR0bSt4ODBlOUFFSzd3UXVpejA4a3l4Rk1XYVRuSE51N3luRVQ4UGNMbkF2bm4ybmxreHhVVXkKNE1JSUhvd29CQUtDQ0I1d3dnZ2VZQmdrckJnRUZCUWN3QVFFRWdnZUpNSUlIaFRDQng2SVdCQlJhVWJmZ2JZY1JnTTFRY3R5QnY2d1JvM2NpOGhnUE1qQXlOakEzTVRnd09UQXlNelZhTUhjd2RUQk5NQWtHQlNzT0F3SWFCUUFFRkthaUt0REhIckRSY0dvUGQ4Vnp5YU1yMTNGb0JCVDhLa3AxT29ENm1XT1Q4SE5YN0w2VHNIM0Rld0lVSnl0anlNd2RUUzJiaEZGeWJQU2NYakpScnQ2QUFCZ1BNakF5TmpBM01UZ3dPVEF5TXpWYW9CRVlEekl3TWpZd056STFNRGt3TWpNMFdxRWpNQ0V3SHdZSkt3WUJCUVVITUFFQ0JCSUVFRUdNd1dOekozZnJ1d1REellMOXptSXdEUVlKS29aSWh2Y05BUUVMQlFBRGdnR0JBRVZmKzI2RVRmTElUS25mb29MaHlBK3VtR2RaUWl6Y3JQRlBiTmcrc2k2TG5pZHRSS3BGbUJVbXpQY2tYZGpoWnlmeEtDMUFtVE1xSnVSQ3UxcTVFRWNPY2hVeEI0WHNXczJMbFBWQlZDWnpiS25TV3hUZ0NtcGV6TlkxQVUzMzhtOU9xbGZ6M3RsYjJwNmZFZGlJUXpKa0VCSGJRRFloV0RJTWozRHI2VUFTOXFrbDNBb09HcWx1MndtWVVNMWRRM1IyUnRBaGNtY3VQeW95NFRhTFRuRUl1aDBiVVE2QUNzL0NNYlUzQy9RWitPVUx2ZDU0eWpoanI0cEhWMUtndzU4MmtiVWNSTnNna2JkbXQxd0FzcU1sL3BDSmdZa1oxT3lobU9hNWJWT3JxSGY0T2ZXditYdE5aN21WVFY4cWFiNy9jOVVaTVRWdWl1QllCb2NLSUJoOG1ITmUzM0xDbGpmOUI5YUNwS3NBMWxPQnB0OXROOFd3SzFPV1ptWGpzUmcyRWQ3TXRvQUZMQ3BtTkhqT2d0eWYxNU9kbHdrZjZla2ZwV21HaEVEckdhMnBFenVHbEhnS1VWOVBrTTVKc3EvRHdCN1FmcDVYWVU5Yml4THVuVXBwOGZOeEdQSXZrOWVFa0dveUN4M3BMSlA2ZWxrdysyWkpCNS8rYlo3UVI2Q0NCU013Z2dVZk1JSUZHekNDQXdPZ0F3SUJBZ0lRUVNiU3cwWlZ6N09HazRFYUg4MGUvekFOQmdrcWhraUc5dzBCQVFzRkFEQlBNU1l3SkFZRFZRUUREQjFUVTB3dVkyOXRJRU15VUVFZ1VsTkJJRkp2YjNRZ1EwRWdNakF5TlRFWU1CWUdBMVVFQ2d3UFUxTk1JRU52Y25CdmNtRjBhVzl1TVFzd0NRWURWUVFHRXdKVlV6QWVGdzB5TmpBME1UWXhOREUyTWpOYUZ3MHlOekEwTVRZeE5ERTJNakphTUVveEN6QUpCZ05WQkFZVEFsVlRNUkV3RHdZRFZRUUtEQWhUVTB3Z1EyOXljREVvTUNZR0ExVUVBd3dmVTFOTUxtTnZiUzFETWxCQkxWSnZiM1F0TWpBeU5TMVNVMEVnTFNCcE1UQ0NBYUl3RFFZSktvWklodmNOQVFFQkJRQURnZ0dQQURDQ0FZb0NnZ0dCQUt2ZytmQXNrM0gzcTI3NVNjYVEyWElJQk5GNzN4RGFrN0RjSnpWOGlkaWlFZ2FIR0RRZXdpcXFjRlFRWkQ5ZTNiSE1adTQyWlY0VXVrN293ZUxjSUNZZnl1aVEyd2xSeEtwMDFkTFJmVTVYOUp2a3BoczBSVStUT21kTGRZSXF0dUZJNHlHcmNaeXQwN2lWS2QzdHRlQUdxc1MyaTZmVGJRc095LzE1VU1iaWNXWG5mK29iZGM0N2cyZVo4MWVPVWNqamoyT0lrMUdxcDZUMmFmcHVEbm1UMTJ0RFY0dm9pVi9YM3N0ZXNvVERwaFpEaWVtdGthaTd5OHhyZlJSYnRTd09obDdvaitqU2VZUk9WMmkvQm03MXd5ZVkxM3AyempnWmQvcDRFNTVueXRSNndwLy9ycisxTUFOWklVZ0NPUXNHUzg3b3I1Sjl3VGpKQ1k5VkE1QTFreVJ3cjUxQ2NEV2FyZUJXaUhXMXRaNDhHRjZtRXdJWm51NXFJMEgzK3pBdFlFRlFHM3FaT1BCUG93RDhvbmR3bmJkNjE5Rnc5cGRwTWNaQTdTcnVFKzZUSjc1SmNGWUpkOUlLMnRFNURDMXFyc3gyNStTUElndEgwOCtab1lCL0NVR3RxRTZVdk8ySFVySFNPVVFjU2t2emZMci9QcmplV3M3TEU1OWlrd0lEQVFBQm8zZ3dkakFmQmdOVkhTTUVHREFXZ0JUOEtrcDFPb0Q2bVdPVDhITlg3TDZUc0gzRGV6QVBCZ2tyQmdFRkJRY3dBUVVFQWdVQU1CTUdBMVVkSlFRTU1Bb0dDQ3NHQVFVRkJ3TUpNQjBHQTFVZERnUVdCQlJhVWJmZ2JZY1JnTTFRY3R5QnY2d1JvM2NpOGpBT0JnTlZIUThCQWY4RUJBTUNCNEF3RFFZSktvWklodmNOQVFFTEJRQURnZ0lCQUp4dElUWHh2R1c3ZlJOaVhkalNnc2poQW5MVGRCZXd4R2U4anpHdUo3RjNFbC9sWU93RXQ5RVhaNjlSek5jdE9QeGRTckFHeHlkdC9wUTRzeG9mYkdsNVZkcWg4QVlLN3NJTzRmQURRbnpQNzRoTnNSL3pXYmdvQmk3Ymk4OEI1QzB4aGFWSm1mTkxLNlZFbEQ3QjhpOFVRZGIwcGROOU1CaTFtRmI1WUM1NmgxS3JWdGhnQUkxa1gyYnJ0ZmFsQ0ZXbDBHZjRtRjhEZVJad2IwSVFPWmFtN0JuMUZQa3Y1bHpPNTZLMlMrQTZ5eDFiUDBUczVIQUFRNThJd3ZQQ1RsMTNxWTgrRXl1SXp0YmxCQkR4aG5UNFJKdVlpQld6UDFFMnhXR3VqbDc0YUc2UGFacDFEOWxSWnN4U1VMZEFGZUZlSi96QjJJbitmVk9PRllXVjlXT2JUUDRveFYrbDNSTEVLNUhMS0FXVXVQLy9ZTzFtSll2VUlyUW9DeGY2RElFaHV2SEx2T2luU0xmTUF5VTdhM1EvTHV1dks4V2F3UGd3L0lFWlRlbEVISmtlSVkrd1FGdnRIUW91NTBKMXBublhhWUt6ZFgyRFd2Tk94c0JET2tTRW5WMTQ3VktSQ2VlZ21nS1hKUXpEVzh5eHUxTU5nZkowekE1aGFBRmZiUE0vWlVmTkJQTGt5RXJVK256Ym05bjhPbkdES1ltUk8wSW9WNTdEeHFrdS9DUURTNGYrVTRQN0JLS0t6TTFiOVdVZm1BNTZkK1FFMnFrLzNiRzFtb3NQMFQ5K1NLWWdGZXZ2VkVyakhzRHNUUzJwaFptZSsyNVVLZ2F0MEdUTE1ib1VIL0pUVTRqbk8vY2Y4aVRVTkY0bnpXbVBSOXh6aE1KUnZLRDlRajF5AAAAw2p1bWIAAABAanVtZGNib3IAEQAQgAAAqgA4m3ETYzJwYS5oYXNoLmRhdGEAAAAAGGMyc2gW8uYcKrcTGYVO8ppj/ymNAAAAe2Nib3KlamV4Y2x1c2lvbnOBomVzdGFydBRmbGVuZ3RoGXFzZG5hbWVuanVtYmYgbWFuaWZlc3RjYWxnZnNoYTI1NmRoYXNoWCCQ5R3DJZMOLLwKxwdtEyg3fV6rqytFlIYuHhew8uDCymNwYWRJAAAAAAAAAAAAAAADG2p1bWIAAAAnanVtZGMyY2wAEQAQgAAAqgA4m3EDYzJwYS5jbGFpbS52MgAAAALsY2JvcqZqaW5zdGFuY2VJRHgseG1wOmlpZDo4OWEzZDMwOS03Y2I3LTQ2NzUtODBhZC05OTg1ODlmZTYxN2N0Y2xhaW1fZ2VuZXJhdG9yX2luZm+kZG5hbWV4GE9wZW5BSSBNZWRpYSBTZXJ2aWNlIEFQSWRpY29uomN1cmx4JHNlbGYjanVtYmY9YzJwYS5hc3NlcnRpb25zL2MycGEuaWNvbmRoYXNoWCCV7INHPNs7+F46V9vBNJcvYGrKCPqi1PqT48LpjzP5tWtzcGVjVmVyc2lvbmUyLjIuMHdvcmcuY29udGVudGF1dGguYzJwYV9yc2YwLjc5LjJpc2lnbmF0dXJleE1zZWxmI2p1bWJmPS9jMnBhL3VybjpjMnBhOjg1MzZkMmU1LWI5OTgtNDgwMi1iYTIyLWM5MmU2MWYyMWM4ZC9jMnBhLnNpZ25hdHVyZXJjcmVhdGVkX2Fzc2VydGlvbnOEomN1cmx4JHNlbGYjanVtYmY9YzJwYS5hc3NlcnRpb25zL2MycGEuaWNvbmRoYXNoWCCV7INHPNs7+F46V9vBNJcvYGrKCPqi1PqT48LpjzP5taJjdXJseCpzZWxmI2p1bWJmPWMycGEuYXNzZXJ0aW9ucy9jMnBhLmFjdGlvbnMudjJkaGFzaFgg4ALO9ASmxH4l+1zzIyrWJJg+eWOz/x0GCO8nyVa1MbmiY3VybHgyc2VsZiNqdW1iZj1jMnBhLmFzc2VydGlvbnMvYzJwYS5jZXJ0aWZpY2F0ZS1zdGF0dXNkaGFzaFggjUoLTed3BQR3QbrkYQFHTBd7Y0yRBsiDtwcOhKYf1j+iY3VybHgpc2VsZiNqdW1iZj1jMnBhLmFzc2VydGlvbnMvYzJwYS5oYXNoLmRhdGFkaGFzaFgg8nQjAkeHKVn1O9cA/rfchKxR4+fEeGSpXKb0y5DAmJJoZGM6dGl0bGVqaW1hZ2UuanBlZ2NhbGdmc2hhMjU2AABMu2p1bWIAAAAoanVtZGMyY3MAEQAQgAAAqgA4m3EDYzJwYS5zaWduYXR1cmUAAABMi2Nib3LShFkL6KIBOCQYIYJZBYgwggWEMIIDbKADAgECAhALpfzpDnCM8gWAMe5EHGRzMA0GCSqGSIb3DQEBCwUAMEoxITAfBgNVBAMMGFNTTC5jb20gQzJQQSBJQ0EgUjEgMjAyNTEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMQswCQYDVQQGEwJVUzAeFw0yNjA0MjIxNTUxMDVaFw0yNzA0MjMxNTUxMDRaMEcxCzAJBgNVBAYTAlVTMRkwFwYDVQQKDBBPcGVuQUkgT3BDbywgTExDMR0wGwYDVQQDDBRPcGVuQUkgTWVkaWEgU2VydmljZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ26ahRMTQKX6oGJthbRvl5YThMDcqGZ32kUcXzlISPTgR+iNZxMoxJKPO9uK7/mZK7XhEtpJFpjz+p2CpCyZdt8ATyN4f7BBTN3ryfeOyA6tA9jh5gbzU2cGr+0fzMRRKpUMDdGuAf9mnlEC3NXVaMDYxF8HRLdrFgv5nqu3qWYwxOTTkjwWvjgfKSSS9VsusrCBSrIkr511JRntVcNqmqabTAwLNdVYYxq0lO2AHgdXkVDnk6SowOA8a9b0bLr/osZ7xa61zcJlatkLZnJh5r4HL8u0OdjgJYamnmgN5M2ozXJSMksmGMF6USbNR6suQinU2wdnGhzyAoeOcwGSfMCAwEAAaOCAWcwggFjMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUOT0QR9yXj6+Ie01zGB3N5e6kpSowbwYIKwYBBQUHAQEEYzBhMDkGCCsGAQUFBzAChi1odHRwOi8vY3J0LWMycGEuc3NsLmNvbS9TU0wuY29tLUMyUEEtSS1SMS5jZXIwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLWMycGEuc3NsLmNvbTAXBgNVHSAEEDAOMAwGCisGAQQBg+heAQEwKQYDVR0lBCIwIAYIKwYBBQUHAwQGCCsGAQUFBwMkBgorBgEEAYPoXgIBMB0GA1UdDgQWBBTznRBN1A3LnXL4Rgp2GEelG2hPdDAOBgNVHQ8BAf8EBAMCBsAwGQYJKwYBBAGD6F4DBAwGCisGAQQBg+heAwowMwYJKwYBBAGD6F4EBCYMJDAxOWJjNDAzLTVjZDctNzY2OS1hZmU2LWZkYjE3MTc3ZDQyODANBgkqhkiG9w0BAQsFAAOCAgEAgjiXbGUfoTcAG/H57Rp0utWmWx419WdsGs8rZmlAzfX80nJW38qVKOr4ZhjeQkM9+AV4oGgeKBmJrbXuf/z1MtKMuF/nbIBu61t8l1sw5xMPLkK4A8Zwmv7+IAmsNUbVoAiMSUWAw7qSH1XHBFoVnW/S69h5m5Y6vEQSkDQFFTR99EGlM5cvLmxRUgptPUmwFcvHhlgRB8zc7p4u6cYHObgzXCDaEu4AVzNULnAoSiUpT5J8LtL6HN1nLnroUHg5UbqDOtqIfpAjkJL1Ylia5cKoc4aexdhx6e8YXGR7ke4PNy92mHhWZOdvQtEQfZIBvIUWam9tGWSF2P8ilu2577LQXBoFhH1oXTVbS7HFaUgWeQbmaI6gxGGYOkz4wCR55aZo4O8Z/daQ1i4tQQxkdRBWX5OUtqGcigIaPLbA6G3zxUPndixoF6Ty5suLiJUW6BF7FSpyJIEQPSHGY20vJYCjmVuqKaX9R+rh92vlBPtbUCZtK6GCXTH13WKofDID3EzHpSxyMFCAV5MGguLorrOnCH+vWTSuEHLvKp2ueKziM+xTtcmZ0iioKjehTqv8zH5YmydtReG0KgecBL0FMFehMS4gLsniyBBU26GSFk++JDWY/i8FadwbuE3j3gcvGuhs9cGK4tP+cnfTE6gr1FeXrgwLBofYAAQBvpO2EolZBlMwggZPMIIEN6ADAgECAhQnK2PIzB1NLZuEUXJs9JxeMlGu3jANBgkqhkiG9w0BAQsFADBPMSYwJAYDVQQDDB1TU0wuY29tIEMyUEEgUlNBIFJvb3QgQ0EgMjAyNTEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMQswCQYDVQQGEwJVUzAeFw0yNTEyMjIxODE3MzBaFw0zMDEyMjExODE3MzBaMEoxITAfBgNVBAMMGFNTTC5jb20gQzJQQSBJQ0EgUjEgMjAyNTEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMQswCQYDVQQGEwJVUzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMs6tM24nMsWKVa4eace+Gv2+diPcsOmmBMarQMqQdphHi5HCFK9HnRRvl0E7HqCtsD7+g/oJ6WL6P5i8wxg8QNfSBrKcwF/c5XkGU5uzE56Nd5YEeHXghfc0hZHQ3eb30gZiHmfozmkWU5e4E4LR5fydULXdj22f6Qi3O0Hxm8f1HJGjNZRx7W3evKT+SMn1YACElB1inCgaOnnvIQofJwq6impwC/+yXYRGUZVsC9j6n2e9BWwRKRA3kA2XESKVGtXSP+7EW+k1eqOwh7XfNi8zmm/oB8ATZNFO5kuedLPAZ6fKbtG2RR4YzCWM1GcXpNt+uU0Slh4sylsXXy4dRuVPJl3IXvYtErr2s3HCArWBMmi3q6Xs7ZRltqSm8Oyu1DE/rakTAOVXS2Sak9i5eAq92mgG5wE1bmTANrRu14OCA5PCMYLr/kpTNDJBOzr87JxUHt2J2iR+VCIuHc12M2h4dfTKedKxodUWSTCZ7JtBwk127rOGLhGpeALi9rhp59qzmAW0hASxPfB3hlzeVXgcLTv6szH/nYciU5mCmmILRDtw0aiKuR/jNQSnFdGLVgYYtXKqPp++MLZYWoWyzVdoJOjsmWoL+3vmOf8frpI9KqhcfyTr3/qp04Yc4hp1ULA+YSShU8Qy1SzPTr43SllEXnKQ56WuIdYliHv0ZF7AgMBAAGjggEmMIIBIjASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjApBgNVHSUEIjAgBggrBgEFBQcDBAYIKwYBBQUHAyQGCisGAQQBg+heAgEwHQYDVR0OBBYEFDk9EEfcl4+viHtNcxgdzeXupKUqMBcGA1UdIAQQMA4wDAYKKwYBBAGD6F4BATAfBgNVHSMEGDAWgBT8Kkp1OoD6mWOT8HNX7L6TsH3DezB4BggrBgEFBQcBAQRsMGowJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLWMycGEuc3NsLmNvbTBCBggrBgEFBQcwAoY2aHR0cDovL2NydC1jMnBhLnNzbC5jb20vU1NMLmNvbS1DMlBBLVJvb3QtMjAyNS1SU0EuY2VyMA0GCSqGSIb3DQEBCwUAA4ICAQDONvo+7w+WNi2OrxFVZv97fwMrDQBrVvXLrR69KoGtpabQTaM+FJPkkxEMadXkjKhu5jdUCBbiJZzsZWYoPDM9ohqaorvNZ2RK5750IQShbsOrJsQ7LNpVuf1HTgTgjXibN4PEdDvFR2HvbUFypNtdQ1PJlk7lHeAEOt+o3S7Rr1iX1uf0XwRyIzxrzwu9OQGrBoyTqI+nD3ZZPuEEkvX32ftGYgWrbm7UiEagsy8qal+lTtr41PzM2aM8qXdFGwrB+Zi5OcvMoXHAKoIScdPk9iXiUSFt1hXf5FONb0p9F45ewLoM1Q53eSGBes7t9xwdm462sopCVp2Pa0EqDv5rnIvuGqMoz1/z6dBkHtbuwolLGOuSz/WvwicFTbiRoTclmeb9gNz0vMc3e760AS1nWPAv58Ozi3HlRAN6MLalsnU+WyN+O9NUpjq5x8wOHDMV1Wo1eoF2fy/+V9pp+Aw+P+9UjwGLe0bDY576H+3Efy9whCv2VoL0p8sk12xeJHs6valYOxgRabOcj9JwdP+Lbia7w6tFx1MFlpxHtcZGq171/IiLGWijNQ/lfGqVZbWr67n/urjgm0pHss7sFS+JAn0V7q+cDE3Eyc4B9TI9j/cmNAv+Iot67fleXmdfURRb2yRW+9FZobfeFppmCbbRhi76B31+lXmbRGZ8NoX29aNnc2lnVHN0MqFpdHN0VG9rZW5zgaFjdmFsWRSLMIIUhwYJKoZIhvcNAQcCoIIUeDCCFHQCAQExDzANBglghkgBZQMEAgEFADCBhwYLKoZIhvcNAQkQAQSgeAR2MHQCAQEGCisGAQQBg78wAQEwMTANBglghkgBZQMEAgEFAAQg6VNnu4b+8MLbR+FGm7c3h5b2BHo8VoOsYr/kI/BF/s0CCDFoOAQCAfAVGBYyMDI2MDcxOTE0NDEzOS43NjU2NjRaMAOAAQECCQC8rq9y1pEN+qCCEGYwggT2MIIDXqADAgECAhRh20YoMoqMjUoGt7/+YOMCbD9xtzANBgkqhkiG9w0BAQsFADB7MQswCQYDVQQGEwJVUzELMAkGA1UECAwCQ0ExFjAUBgNVBAcMDVNhbiBGcmFuY2lzY28xGTAXBgNVBAoMEE9wZW5BSSBPcENvLCBMTEMxDDAKBgNVBAsMA1RTQTEeMBwGA1UEAwwVT3BlbkFJIFRTQSBJc3N1aW5nIENBMB4XDTI2MDQwODE3NDYyNloXDTM3MDcwOTE3NDYyNlowdTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRkwFwYDVQQKDBBPcGVuQUkgT3BDbywgTExDMQwwCgYDVQQLDANUU0ExGDAWBgNVBAMMD09wZW5BSSBUU0EgTGVhZjCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAOrKxa2U/fD9J5/HeKdhBMr/DilhKvuhiM1fqKKXnQ6JL4uRyB+8sJaQPQgcVYLBlo42ahWtiWnokNssRDKDqArNd+U16O6oZFv+uOCOnecCIKEowzXdpxA36SL3CU2XmrSEc8AufKlQRyigtPBpH/Cwhyl6Wf4PFBQ1QvnZaVIXSiA38mjMD/Ett4KWIBtLEQ5GElw9pBSGuEtFZjiiTk0nypW6dQzMTodqn3TDIBUFASRfDcR+XK7+HfMfC5XtAJHfPPWGmyoSXg7WDxzQ3cn6DchNw8mEWhhJLOQ4cxpgUrhM7sbzt7bY3WqpziC6XdbEXDUQZPIDIxFTP2KOZQURXXAr1MlrCYFFUugaV+1aRl3aXXacJXkQaINRpJiEdZFymFX/2ONDYrHtaWcnQbzFj/JqByuDSejhLRg0Drs5B69nvbSVHsgCsr1FZ81yAYiUX1VLBiytr+2l9CSvdwM+g4pkUY+RjAw5lkuwPa76BJmhPhiMPfC+FzahLvVjtQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIGwDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUpCdUgqKKgHs9xYbNP3DZwoOZUXgwHwYDVR0jBBgwFoAU8hTwsMcXVD0jQ4XcynPQcoA9uKgwDQYJKoZIhvcNAQELBQADggGBACD7JE9BwMC8mLIyEiAQjSCZSDUST8RGVn6nPj+2pSP5Kkg+4FGdH0VAeMG7g06TUMmbJ5Zo303O8vYc0nmr7+rBH9o/9ZhZCOZwzYn07keLqsvs/4x+FOFG2JHmnLge5DRG/2HSePh9ODnjUu0bX2boc8AAcjvkqKuOhhsqozch+Tvfe1xU2EzHaipLf89DdGAFgHOjydF3r4ep/bWxhGpuv4gqzpqhmquinoJIBww3xQJjUZfbUnxvHmfJaQhC1c/1+60bXouQ4uAIeTwuGxODap6l6CVBj4UQAe3kGMGgOo3+nVJQGu+H3uFkzVX5ISDftinvnydu0bo0RqtKIk/nYhV33UUj3WEtwjEpj8S5fnkCBqu0V9TB7M8dBuFce2VJsBnrTaukxydATqa0tY/PfMO0Q6d2014wY+6oF641KHRkq1o141svOj5OCmHWME1Dm/9OLsYhuT46LCAZVzB1ao5kS6LQCdEW16BnJkFtZ/gDcHa4JSZW+ZEmJ8NLSTCCBX4wggNmoAMCAQICFASNBMrGxQvF2hmwvPFOEZWl6rwZMA0GCSqGSIb3DQEBCwUAMHgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQT3BlbkFJIE9wQ28sIExMQzEMMAoGA1UECwwDVFNBMRswGQYDVQQDDBJPcGVuQUkgVFNBIFJvb3QgQ0EwIBcNMjYwNDA4MTc0NjI2WhgPMjEyNjA0MDkxNzQ2MjZaMHsxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQT3BlbkFJIE9wQ28sIExMQzEMMAoGA1UECwwDVFNBMR4wHAYDVQQDDBVPcGVuQUkgVFNBIElzc3VpbmcgQ0EwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCJvNS54sihC75hu948ZGZ+p76cbRDTqTAHJjwE9OBrIDnflTTtqaJlCEjbN4Yyg47MCkqgwPM0bKDAmM0rn6X0y3zZDybefslNou9jW5Hm9lmo0gH6TvnZOCtaDs1gWpiBmKjXU8bjGdYuSKxDVwnplPJH+WxFihVgt/euL16iNU6FOIVpnzSd0E3YQz3NNG38Y5P803C7Suh26GpOZkmg7fz4GL7vmhe3qHes77c4zLnUKjPEdg/WQBF3y/7HXRctQNPeizzAGNZAFEGZy5Q/LH0Aa1L8nspQtwlHRRXhBSNV+rFPb1SYlfR9uvho4SIcetyKkUOLFbYuEkOxYhygvsokji7vv6TRTei4PzHPJj3FAFDq8tkkIGTt1XOeLnB4qt5WPAX51ICi6K2v9vuoo1zLaKtE2zB38sQ0dGtVbcaH+/IyPJ5xDkUT9+xQD/v+1gQxJrvQxE1h4kLbr8Mrbl8rGRvm4rDvjVxEzR/Ac32Poum9bYK8JWWECDBp7RUCAwEAAaN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwEwYDVR0lBAwwCgYIKwYBBQUHAwgwHQYDVR0OBBYEFPIU8LDHF1Q9I0OF3Mpz0HKAPbioMB8GA1UdIwQYMBaAFFjCQKA8R3YrqOZuqJGWjpbIt9nkMA0GCSqGSIb3DQEBCwUAA4ICAQCS7Ddc3mzrZNquoREJMHKu3HII9Tu8D3o91sbhL/aDM33oH1dAGE5Mmapr1JnZFIvba9ZM+MrQWTPToaA4XCOIRCT7h+H2kwYnvKHtTF9nXf81qzHS7HsR1EBDN0/ChBucumTID7CiHX6aNvjh0IKzUEOy4FW9gJTIWVJOSnTeXcdFWJu3+jCqO9xHvNUuLLk4GGMseVq33VWtPULfiAPP8Wj+cwDUWrfeJAKXkcDnZ/7cpgrzpUYRs1EcfxLPja9f4xjIuEDGveP51ktx0GRd5WTCS8Bed9E9x1ueFc97/ZSU5wFLCFHa+2T0qxHwNZTx9r5+Kw7dspo9UN1Qw5Zkjm2rDHOfKAY7BHfQl+1vRU+xMy5fRuuDtqlhH7zXgq74gG/C42kVMOZtfDpEkisGmC2v3DTBvqUqSOeHyN44DLUEDDPK44RQcPGyHkvejU/2kRncX4X68ebR18qn7rSf9iF4KYHw43BYdwEQhqQ6S5eDRujawmp2yakSyyEcD0W+ZbGghi6AvFlLTZtDH22014Tg/PDVyGGQDUOOE2qdw/EhPIRdBv471tgjOUULXx1xDfoy/aCAlUS1TwDlw3T94k6Hcob08FEBhx4IvdS1KzVsBhCSpDtrap26/cA7B5x2wgzVGDl/SdrjlBw+UAhq10ziiWGd7+vPxcNAbnB6ODCCBeYwggPOoAMCAQICFBNQO2yJjPAkAzMsj/dPjvt9guwbMA0GCSqGSIb3DQEBCwUAMHgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQT3BlbkFJIE9wQ28sIExMQzEMMAoGA1UECwwDVFNBMRswGQYDVQQDDBJPcGVuQUkgVFNBIFJvb3QgQ0EwIBcNMjYwNDA4MTc0NjI1WhgPMjEyNjA0MDkxNzQ2MjVaMHgxCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEZMBcGA1UECgwQT3BlbkFJIE9wQ28sIExMQzEMMAoGA1UECwwDVFNBMRswGQYDVQQDDBJPcGVuQUkgVFNBIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQD2kunSFLqtnuEarHWoVhvYqrGzapJflnn1krcULST4v8Aar2C+wZrNeZrcbJr+NprBmBakP+QsnbqlpVBzswrC+RrzxEkveL3S7LznP/Sb0RoP8qBhoiyJJcpRBhEX+SUQnNLGL/SJxEESDv4mHtNtNc3suzVgQKiFUb727pCY8SrYnXoQa2rZLtlj8+UUXCnFhiLBihxozes4nqlQllsjQ/s4/0J8OzqhUS8lyUjcMf9Qcu7wfKF3zRhvgWHzP79u6NIbsaYINuRrMvv+d6hem1zd3TGQTI5l/xaBy0HOKDFTyhhDzkgEbn3WZBazKRDktC46t1RaclZX86hqfR7v5mEf3WXIDkgJSZkydPAKoszdkwBTrCO9goUgse++7R2hdwDuOkYzop7sr+kGMWa0Zm+yiZOgfpUODyHOQfhe8I7pzbnA1TNdeNDQJzHPUDBycx0e2mrCwJPPrdwPZIf2+whOiHb1Pu//kiyZdy4L9gbcmLadCQM6/fQaCcePX1rpfkgNCSu1HoqDGwTyWxU8LBADr5GinUG3UmjRDREaGb+wwNpPYL3uKarth41xXCiMjYijJRRjRdgF/Hthj2xGVDsYXMmwgq+DyLEjPxyfGlvuotdUtSpTrruF26b6l57shIly83pAyRa2hVhHW/EkYTmiTN7Yxqgi8p6/W0wsywIDAQABo2YwZDASBgNVHRMBAf8ECDAGAQH/AgEBMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUWMJAoDxHdiuo5m6okZaOlsi32eQwHwYDVR0jBBgwFoAUWMJAoDxHdiuo5m6okZaOlsi32eQwDQYJKoZIhvcNAQELBQADggIBAFj4gZEMmPJsYf7Ihh3WW4Qdpta+uKZdDF1Jy7ihKc0tnbhY+fCEiT08+G/Vah+0KqJVkvBngZletVQM+5pGgOMCUQBTwA4DwYhX3u+CVX7j9H0Y6w8m/IP/IajBrN7bG5OrGc3QMHYYOpOdzqpnAw05Gi6AdN9t8H4Tdi/p6lBBizg9bOXgPu4v22RUNl4RvmJFttEhtIA8jBjr2pzWSqnVVGVba9FYfsBJh+vrS1+SDDuU15qG9qFZzkfwOKzDsH8DdGTRwFI7obF7KGvhDmmX+AIYDCgXOyf/rqQQnvdly6D06rm9lM5E4pixCkho7lWpIaVgj/7K1n3Re4YgnA7zqHjQxtpALsiBBQtcYqgqwftW5xh5B44Rr+zl29Nw/kbMY6hk8Tzpr6VkvF6/hQgtHrDO47nTpBHXUrtwi4ad+y6/CvbSVSsjQitDXOyhgmE/z3HtsPeX6eTLwjz8rHe3ttwgwUzpibIPsi9/w36SZJwItYTezJb9ibBLtUN90umthv0Z2S2fvQDuwLRHViN8SBWRDk4PZ4kge2IIwcleVfH2BsZRI1dv74e+FCBGeb6UArHIICidlYqIJlUFZlLvGH/ZS7qoWhTpwiytnwvDXELzofUnZHlxjApanv25+UV5B3Ae4WoDtTeWjlj9Rb9UJYyDAz0P2SYzI9BYd6a4MYIDaDCCA2QCAQEwgZMwezELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRkwFwYDVQQKDBBPcGVuQUkgT3BDbywgTExDMQwwCgYDVQQLDANUU0ExHjAcBgNVBAMMFU9wZW5BSSBUU0EgSXNzdWluZyBDQQIUYdtGKDKKjI1KBre//mDjAmw/cbcwDQYJYIZIAWUDBAIBBQCgggElMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAvBgkqhkiG9w0BCQQxIgQgkdSFB4gQEmskegCR4sMzv1uASxHB5DDtpip+v/I64k4wgdUGCyqGSIb3DQEJEAIvMYHFMIHCMIG/MIG8BCC9T7mykEyBNmeIbu9B4W3+BNkiB52/W5JK0KLEYEYiejCBlzB/pH0wezELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMRkwFwYDVQQKDBBPcGVuQUkgT3BDbywgTExDMQwwCgYDVQQLDANUU0ExHjAcBgNVBAMMFU9wZW5BSSBUU0EgSXNzdWluZyBDQQIUYdtGKDKKjI1KBre//mDjAmw/cbcwDQYJKoZIhvcNAQELBQAEggGAt+o7bV3p6L20GAAstzQGc3StU+OmnF8RpgmXdsSv7W4p5boHNuKC7i1lfqBdNEUWkUbAOsUYLdcsyOGZ3vWAVO8Wtye2jwcCZPuufQ0zYtzTvLs0Dn8z4k4FdGI3TEJQnQN+9F0En2m2xL9Wi1EX1d0Y9SDHUR1rQMQ4s936S3AhUEwo/bpqykjkxpOFh3yNswCv2wI7ezBUuC1KzVPlozBjHZSAY2CAvlG+IxAjjnoGu5Lobk5ebdIzWEJjO3I/ySglc0XRXm3F5qATTvlWrw/NnaSombSMiDRHzyE5jl+PyRCWAx7L9TLhYsi6w7zSPzwZsdWjoYdGG/5PtoQyLygAvbRE8NkunXqnVsqBxw/SVHeoUNcJdIo12yUO3c2GdRpVDn6/NyLrjTVuPHKk/H1JrlK42Br0rinX5rgJ4hGNcIq+IuFfvcrwgVcSyOK75TyRMRWjRaRJP+nKryZqrrnIo+OxnCqZjjGKGc0ZHY40DgEV/LYonoFXmQeQM2nKZXJWYWxzoWhvY3NwVmFsc4FZB9cwggfTCgEAoIIHzDCCB8gGCSsGAQUFBzABAQSCB7kwgge1MIHpohYEFBz7V6LAG0vGt56LVXV6PVR+ZENdGA8yMDI2MDcxODA5MDIzNFowgZgwgZUwSTAJBgUrDgMCGgUABBTfgjdTXlPYM7HgBD0kNfF15uEKGQQUOT0QR9yXj6+Ie01zGB3N5e6kpSoCEAul/OkOcIzyBYAx7kQcZHOAABgPMjAyNjA3MTgwOTAyMzRaoBEYDzIwMjYwNzI1MDkwMjMzWqEiMCAwHgYJKwYBBQUHMAEGBBEYDzIwMTYwNzIwMDkwMjM0WqEjMCEwHwYJKwYBBQUHMAECBBIEENCE9Oar+wMrz4R/lS0EIAMwDQYJKoZIhvcNAQELBQADggGBAEa3lfeAcmEdhR2Vsob92Uou2Q8G8jcMwFu1IVyhIeZindJLIpr3QMrMv60jiHDGJmhzMsxOA4pA4BkoiFEpoTwwbH0S2QrUC58eptqXGGr1WUOJt2meAme4DHMFTkOU6OKstNFN/KA0KtlWE2hIfhPvXwYuSwXHmlVjxnUVe5a8LNqa2BIaCKwoHVP8uJJRvJYP9clqN4PSL7TiRESa+GPQqmS7vMn6935r4g1uxYCAx5btOO71WpJB7S5bYcqF37BcDAbLC0VbdYNTrNEfO8RHkpBwU6t7xNPuBVNZaeaf+UR8b8qKFjz8afwiTrVSxDz5h0GL5zeaTmsOxVsFlgiCCZbXC9oEFQkvGwxhqVCvAwimYg5+Gi5jhWyy6DDutm16gnWQslDBUHg71cIDfDzTz7bp5cchpfj21nJjAFrBkDrneaMCTQbNx2WQszLt/nVbovueubHF89GSIURTA6YNE3WoSL0Jxp3hoHSziZspMZYnzbzMbcO23RXxmo3UzKCCBTEwggUtMIIFKTCCAxGgAwIBAgIQY3Lq91wcTbEnpV933Z92GzANBgkqhkiG9w0BAQsFADBKMSEwHwYDVQQDDBhTU0wuY29tIEMyUEEgSUNBIFIxIDIwMjUxGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjELMAkGA1UEBhMCVVMwHhcNMjYwMTAyMjExMTU1WhcNMjcwMTAyMjExMTU0WjBNMQswCQYDVQQGEwJVUzERMA8GA1UECgwIU1NsIENvcnAxKzApBgNVBAMMIlNTTC5jb20gQzJQQSBJQ0EgUjEgT0NTUCBSZXNwb25kZXIwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDPgm+LI23Zqo9kTfYYXv/gqnGyrI4cstylpch4ZCqfmjWsV6sodsPaXAeeJrIUwuFoQXRRIJFJ4BgSyBjwxdXbdPTB1HN+eBQ9Z+ghO2g6JicdpOTpiKee21ljR78nN+o+Cw9OIfyywu+yIoRh9/cq463pCRQgJldhZPNqgKx+ZTquc91M3ahpFzvFd1jp1K3I9QWfNJJP3RUSlH6QTYigAk9PlPfUdicZphim2NOjKu3rYON5VgkBH0mUpWBzy8JsQfPPenmUrRH0/5F459OzW3Db8o6B3AuKzEfiokq8Egy6pVJVZVk9p4eD9XrDUvzOdfToecSRWvRzlMt0Gv59g42fICH1R/5DW88MXi2uevpdAtRZzavnqUvY1RmXDCzRYxi96joc2/hXXyla0s2uZFCew/SAItOKraK7i3Gd4bgltF5SdeX6nCwnCLXCTFw7UM2sraAYQp54kt1kOy0+tlo6lIdwjZozK9fuClAzLMXjbrCQCihrcV3H1nng5icCAwEAAaOBhzCBhDAMBgNVHRMBAf8EAjAAMB8GA1UdIwQYMBaAFDk9EEfcl4+viHtNcxgdzeXupKUqMA8GCSsGAQUFBzABBQQCBQAwEwYDVR0lBAwwCgYIKwYBBQUHAwkwHQYDVR0OBBYEFBz7V6LAG0vGt56LVXV6PVR+ZENdMA4GA1UdDwEB/wQEAwIHgDANBgkqhkiG9w0BAQsFAAOCAgEAMeW1a392G9fC2yp96R+PrtybL+/eHuaBeOc1pqFSWwxua1yLdGkZKgCAzZaI4YZtuddWoJOpbyKe1FZUKZTavzIswozqJFRfNCrXU2bCv0f2/+ydh1GeNEEPy2QPQXh+Maw2HIdMdRvGkxnGtE0B7RqH8YA1+1AHj8dPWhX7cQm+mmP+y4d+hiGWPwqBzFeH8FQmdt2opexxrR2XBDo3mejRpdIhwJOj+2/eSWT92bVasCw6vz++UqIYKdTtsC6KLBtKIzH6p7CGtoiVsNqQPHvSZkEsrmoVS8r3UwI+mL18ssS16Qc0vxQrlkkrqUIx3xXCyS2elb0OZbr5ezJ7WMHxq1YmKVB4OzcKhCpCh+Fu8998uwsgUl+DfUSd2MWySrXlGdCAwwTx2ccBmCBlmv+RR/Kty3lPX0lBZcK8DE+rV3SNW8fYiRiLpg3gGr45kmbPs/ic23Kb3Aio4Hz/IM2CReNLjvFB2P6pg9KCnJJpfS5WcGmLybj0cu34/R7rO8zI6rVSTwipI5NlLoFb3pMBxR3YV49AxyIaUOM5eof6xMH8IUuG/H6/ktxPhmOKBb1eQ0SEVzIB4O6I37hCGFOnetfk+NlaaZWfL8TMx3EYTtiPrVddG22b7HzR70AQrvBC6LPTyTLEUxZpOcc27vKcRPw9wucC+efaeWTHFRRjcGFkWSL4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9lkBAJd4wfo596pD29f7AN2f7lXdB5MF+9K8w4gHdXnauUhLLSQPvnscsi7jDkAERniWQeAOX6EaJyDtVFYLx4u6jRSl30+8OZ2xmdnLou37NafCbGQ8JTJPNp/dKxGc6tMmqjt+D19xBFPWaYfxVT2WlRZho0VDJVcpIAzNQrZrb7uY+qyEfpyGaKmBmSc8a7EdpcLEsegJxJfnbi/QzFp2rbThqAYrxFpehEiHNBMAq1CZeMfz9HLJ9HV1myaHjUaacMCNExG+/NFXUq8iIn3lHF4GHPWKYTb7goBH4p/VumUCzOOEJlBxZynKEz1iMLoKd2BfHpvea8M1uW/dAYS1umD/2wBDAFA3PEY8MlBGQUZaVVBfeMiCeG5uePWvuZHI////////////////////////////////////////////////////2wBDAVVaWnhpeOuCguv/////////////////////////////////////////////////////////////////////////wAARCAQABAADASIAAhEBAxEB/8QAGQABAAMBAQAAAAAAAAAAAAAAAAMEBQEC/8QAMRABAAIBAgQEAwgDAQEAAAAAAAECAwQREiExUSIyQWETcYEjNEJDUpGhsQUUcsEk/8QAFAEBAAAAAAAAAAAAAAAAAAAAAP/EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAMAwEAAhEDEQA/ALoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA82yUr5rRHzlFbVYY/Hv8oBOKs67HHStpeZ13bH/ACC4KM663pSP3c/3sn6agvih/vZP01d/3rfoj9wXhSjXd8f8vUa6nrW0AtiCurwz+KY+cJK5cdvLeJ+oPY46AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADk8uoOivk1eOnKPFPsrZNXlv08MewL9r1pG9rRHzQX1mOvl3soTMzO8zMz7uAs31uSfLEV/lFbNkv5ryjAAAAAAAAAAAAAeq5L18tpj6pqazLXrtb5q4C/TW0nz1mv8p6ZaX8tolkgNkZmPU5afi4o7Ss49ZS3K8TWf4BaHImLRvExMezoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkzERvM7QgzaqmPlHit2hSy5r5Z8U8uwLeXWVrypHFPf0VMma+XzW5do6IwAAAAAAAAAAAAAAAAAAAAAAAAHqmS+Od6WmFvFrYnlljb3hSAa9bRaN6zEx7PTJx5L453pOy5h1db8r+G38AtDjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIM+pri5Rzt27AkvkrjrxXnaFHNqrZOVfDX+ZQ3yWyW4rzvLyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACfDqb4uU+KvZexZaZa71n6dmU9VtaluKs7SDXFbT6qMnhvyt/ayAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTO0byo6nVTfemOdq+s9we9Rq9t6Yp5+tlNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW9Pq9tqZZ5ellQBsRO8cnWdp9TOKeG3On9NCJi0RMTvEg6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5M7RvIoarUcc8FJ8PrPcDU6mckzSk7U/tWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPp9ROGdp50n07IAGxWYtETE7xLrO02onFbhtPgn+GhExMbx0B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFfVZ/hV4a+ef4BFrNR1x0n/qf/FMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrSajhn4d55T0nsqgNkVdJn468Fp8UdPdaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwHnLkjFSbT6Mu95vebW6yl1Wb4uTaJ8NeiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHa2mtotWdphqYcsZccWjr6wyk2my/Cybz5Z5SDTHIneN4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVtZl4KcET4rf0sWtFazM9IZWXJOXJN59egPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL2iy8Vfh26x0+S2yKXnHeLR1hq0vF6RaOkg9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5aYrEzPSAVNdl2iMcevOVJ7yXnJkm0+rwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt6HLtM459ecKj1W00tFo6xzBrjzS0XpFo6TG70AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq67Jw44pHW39LTM1WT4mae0coBCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7oMm9Zxz6c4XGVgv8ADy1t6erUB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEea/wAPFa3aGUva++1a07zuogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANPS348FZ9Y5SzFvQX8Vqd+cAvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5M7RuDO1luLPPavJA9WnivNu87vIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXTW4M9Z+iJ3fbmDYHmluKlbd43egAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWotw4Lz7JVbXTtg27yDPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABpaS3Fp6+3JOqaCfs7R2lbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU/8hPhpHvuuKOvn7SkewKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALegnx3jvC8ztDP2/zhogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM/XT9tHtVoM7W/ePoCuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACfR/eK/VpMzS/eKNMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABna37x9Giz9dH28fIFYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEul+8U+bUZmkj/6KtMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ18faUn2X1P8AyEcqT7gpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsaL7xHtEtFQ0Efa2ntC+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAra6N8G/aVlFqK8WC8ewMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF3/AB8crz8oXFfRV2wRPed1gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByY3iY7ugMe0cNpjtOzibV14dRb35oQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe8dePJWveQaWGvDhpX2SOOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAp6+nKt/pKk1NRT4mG0eu28MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABZ0NN802/TCs0NFThw8XradwWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcZeenw81q+nWGqp6/HvWuSPTlIKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO1rNrRWOszs1q1itYrHpCjocfFlm89K/20AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHjJSL0tWfWHsBj2ia2ms9YcW9di2tGSOk8pVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT6XH8TNG/SvOQXdNj+HhiPWecpQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4y0jJjmk+rKtE1tNZ6w2FLXYvzY+UgpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANPTYvhYoifNPOVTR4viZOKfLX+2iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5asWrMTziXQGVmxziyTWenp7o2lqcPxcfLzR0Z3TlIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO1rN7RWvWXF7R4eGvxLRznp8gT4scYscVj06pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUtZg/NrH/Uf+rrkxvG09AY4n1OD4V948k9PZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACTDinLfhjp6z2BJpcHxb8Vo8Efy0HKUilYrWNoh6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5vSL1mto3iWZmwzhvtPOPSWq8ZMdclJraAZIky4rYr8NvpPdGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD1Slr2itY3mQKUtkvFaxvMtPDiripwx9Z7uYMNcNdo52nrKUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHjJjrlrw2hm5sNsNtrdPSWq83pXJWa2jeJBkCbPp7YZ3617oQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASYsVsttqx857A80pbJaK1jeWjgwVw15c7T1l6w4a4a7V6+spAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcmImNpjeFLUaSa72x847LwDGGjn0tcnir4bf2oXpbHbhvG0g8gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsRNp2iN5n0XMGjiPFl5z+kEODTWy855U792hSlcdeGsbQ70dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeL0rkrtaN4ewGfm0lqc8fijt6q7YRZdPTL1jae8AyxPl0uTHziOKO8IAAAAAAAAAAAAAAAAAAAAAAAAAAS4sGTL5Y2jvIIk+HTXy8/LXvK1h0tMfOfFbvKwCPFhpijasc+6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWTBjyeavPvCUBQyaK9edJ4o7eqtatqztaJifdsPNq1tG1oiY9wZA0L6PHbyzNZV76PLXptb5Arj1alq+asx84eQAAAAAAAAAAAAAdiJmdoiZ+QOCamly3/AA8Me6xTQ1jz2mfaAUuqbHpct+cxwx7r9MVMflrEPYK+PSY6c5jin3TugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTG/VHbT4rdaR9OSUBVtocc+W1o/lHOht+G8T84XgGdOjzR6RP1eJ0+aPy5agDJnFkj8u37OfDv8Aot+zXAZHw7/ot+zsYsk/l2/ZrAMuNPln8uXqNJmn8MR85aQChGhyT1tWEldDX8V5n5LYCCulw1/Dv80taxWNqxEfJ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf/9k=\"\n }\n ],\n \"output_format\": \"jpeg\",\n \"quality\": \"low\",\n \"size\": \"1024x1024\",\n \"usage\": {\n \"input_tokens\": 18,\n \"input_tokens_details\": {\n \"image_tokens\": 0,\n \"text_tokens\": 18\n },\n \"output_tokens\": 272,\n \"output_tokens_details\": {\n \"image_tokens\": 272,\n \"text_tokens\": 0\n },\n \"total_tokens\": 290\n }\n}" + } + } + ] +} diff --git a/packages/ai/test/fixtures/recordings/openai-responses-images/generates-and-edits-an-image-with-the-hosted-tool.json b/packages/ai/test/fixtures/recordings/openai-responses-images/generates-and-edits-an-image-with-the-hosted-tool.json new file mode 100644 index 000000000000..b1c24341ae02 --- /dev/null +++ b/packages/ai/test/fixtures/recordings/openai-responses-images/generates-and-edits-an-image-with-the-hosted-tool.json @@ -0,0 +1,50 @@ +{ + "version": 1, + "metadata": { + "tags": [ + "prefix:openai-responses-images", + "provider:openai", + "protocol:openai-responses" + ], + "name": "openai-responses-images/generates-and-edits-an-image-with-the-hosted-tool", + "recordedAt": "2026-07-19T14:57:16.284Z" + }, + "interactions": [ + { + "transport": "http", + "request": { + "method": "POST", + "url": "https://api.openai.com/v1/responses", + "headers": { + "content-type": "application/json" + }, + "body": "{\"model\":\"gpt-5-mini\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Generate a simple flat black triangle centered on a plain white background.\"}]}],\"tools\":[{\"type\":\"image_generation\",\"action\":\"auto\",\"output_compression\":10,\"output_format\":\"jpeg\",\"partial_images\":0,\"quality\":\"low\",\"size\":\"1024x1024\"}],\"tool_choice\":{\"type\":\"image_generation\"},\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"stream\":true}" + }, + "response": { + "status": 200, + "headers": { + "content-type": "text/event-stream; charset=utf-8" + }, + "body": "event: response.created\ndata: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_028d7fb658c136b3016a5ce59cd0e8819f804427824478bc8c\",\"object\":\"response\",\"created_at\":1784472988,\"status\":\"in_progress\",\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5-mini-2025-08-07\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"in_memory\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"medium\",\"mode\":\"standard\",\"summary\":\"detailed\"},\"safety_identifier\":null,\"service_tier\":\"auto\",\"store\":false,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":{\"type\":\"image_generation\"},\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[{\"type\":\"image_generation\",\"background\":\"auto\",\"model\":\"gpt-image-2\",\"moderation\":\"auto\",\"n\":1,\"output_compression\":10,\"output_format\":\"jpeg\",\"quality\":\"low\",\"size\":\"1024x1024\"}],\"top_logprobs\":0,\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":0}\n\nevent: response.in_progress\ndata: {\"type\":\"response.in_progress\",\"response\":{\"id\":\"resp_028d7fb658c136b3016a5ce59cd0e8819f804427824478bc8c\",\"object\":\"response\",\"created_at\":1784472988,\"status\":\"in_progress\",\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5-mini-2025-08-07\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"in_memory\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"medium\",\"mode\":\"standard\",\"summary\":\"detailed\"},\"safety_identifier\":null,\"service_tier\":\"auto\",\"store\":false,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":{\"type\":\"image_generation\"},\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[{\"type\":\"image_generation\",\"background\":\"auto\",\"model\":\"gpt-image-2\",\"moderation\":\"auto\",\"n\":1,\"output_compression\":10,\"output_format\":\"jpeg\",\"quality\":\"low\",\"size\":\"1024x1024\"}],\"top_logprobs\":0,\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":1}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"rs_028d7fb658c136b3016a5ce59d154c819f85755db041801f6a\",\"type\":\"reasoning\",\"content\":[],\"encrypted_content\":\"gAAAAABqXOWdHS2Caj6M3NNE0u_5cAteF-ddZxQ_bD8o8hg48tu51gsxk9_NWz6Vjzcj7cgCJb_qHopoZdYXt8mAlpreQsxAUKu9WLxCfgsmLuDoZDE38gl6HA7xz-YTW8VOWunsj3PF1MJZFzYIjJuZtPiVU8JtP_vabifALFe5cQlqLI3zkNHEbRdDy4hncruHJoAstZcpaVUSkqI_mivfCFYvW6qfqLquHZJx13KQEh-mpALPsJGKfg7r2t0U3z6BTxeCcuYwlvUQIHYBbABysMv_OCc-xXcsRTalMh41EeorMOIoz-CQh_QCQAxbfo3nMIdCJH4KoR8bjd4n8wu_Rz0wu_t5K6fBrO4ksr8pEY1EXBG_qc_XfM4OWQjQ2y6U3q41pmGZ4Ywh7FKfz0cp2J08BbwB1eBb7WvmZWaevUMNV5jtoU61tswFJdUoLDxJ2u_n_BTv9YLhXa3xlU0ZnsoVzfwuC5l8JrdpCMERfFdpWVplLxftZwFj5vgGtYH0buosjyEWeoN8COn-zUs7f7EDHOg_vICo3b4vF8lox2REJnC9Kr0OJI4FqyTOs_VDLCT3hUWG3oHseCmLKJbCD5JYkmmp9TUu64bpzJR1isMbrCBEpwKU3px-pc33HeayLsdC6kMCtN0eJ6G7FwElV6tdmxGyAX2zGzgWsMhvgCwuLrDLDkP-2K2z9jKFhXO5iXZqsERY08RGX0_utEFJOXD4tFDdrwlOMNyVzRtTaGGuhajhFqMYe_urqDG1YljAlRleDy5ALNZHGXu_Q78c3PMfBkAxGtVKqX5gTCd2JpuYTiEsrMktqj8Kqri9asQ65Bye6IOtmKjXOXVioDV7USsMDJ72f-nIpvWsdgMkhR1WG786qBwShudSk0KRyIMMMGrNVuMBoIhY1_cyLd2zLgClH5U_aWR5qngSOX8xquak4KBQFp8=\",\"summary\":[]},\"output_index\":0,\"sequence_number\":2}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"rs_028d7fb658c136b3016a5ce59d154c819f85755db041801f6a\",\"type\":\"reasoning\",\"content\":[],\"encrypted_content\":\"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\",\"summary\":[]},\"output_index\":0,\"sequence_number\":3}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"ig_028d7fb658c136b3016a5ce5a91890819fa161dd35e5e7c1b1\",\"type\":\"image_generation_call\",\"status\":\"in_progress\"},\"output_index\":1,\"sequence_number\":4}\n\nevent: response.image_generation_call.in_progress\ndata: {\"type\":\"response.image_generation_call.in_progress\",\"item_id\":\"ig_028d7fb658c136b3016a5ce5a91890819fa161dd35e5e7c1b1\",\"output_index\":1,\"sequence_number\":5}\n\nevent: response.image_generation_call.generating\ndata: {\"type\":\"response.image_generation_call.generating\",\"item_id\":\"ig_028d7fb658c136b3016a5ce5a91890819fa161dd35e5e7c1b1\",\"output_index\":1,\"sequence_number\":6}\n\nevent: response.image_generation_call.partial_image\ndata: {\"type\":\"response.image_generation_call.partial_image\",\"background\":\"opaque\",\"item_id\":\"ig_028d7fb658c136b3016a5ce5a91890819fa161dd35e5e7c1b1\",\"output_format\":\"jpeg\",\"output_index\":1,\"partial_image_b64\":\"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\",\"partial_image_index\":0,\"quality\":\"low\",\"sequence_number\":7,\"size\":\"1024x1024\"}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"ig_028d7fb658c136b3016a5ce5a91890819fa161dd35e5e7c1b1\",\"type\":\"image_generation_call\",\"status\":\"generating\",\"action\":\"generate\",\"background\":\"opaque\",\"output_format\":\"jpeg\",\"quality\":\"low\",\"result\":\"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\",\"revised_prompt\":\"Simple flat solid black triangle centered on a plain white background. Minimal vector-style graphic with no shading, gradients, outlines, or textures. Triangle pointing upward (base at bottom), crisp edges, centered both vertically and horizontally, occupying about 40% of the image width. High resolution, clean white background.\",\"size\":\"1024x1024\"},\"output_index\":1,\"sequence_number\":8}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"msg_028d7fb658c136b3016a5ce5b662b8819fa19ff40122f1c07a\",\"type\":\"message\",\"status\":\"in_progress\",\"content\":[],\"role\":\"assistant\"},\"output_index\":2,\"sequence_number\":9}\n\nevent: response.content_part.added\ndata: {\"type\":\"response.content_part.added\",\"content_index\":0,\"item_id\":\"msg_028d7fb658c136b3016a5ce5b662b8819fa19ff40122f1c07a\",\"output_index\":2,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"},\"sequence_number\":10}\n\nevent: response.output_text.done\ndata: {\"type\":\"response.output_text.done\",\"content_index\":0,\"item_id\":\"msg_028d7fb658c136b3016a5ce5b662b8819fa19ff40122f1c07a\",\"logprobs\":[],\"output_index\":2,\"sequence_number\":11,\"text\":\"\"}\n\nevent: response.content_part.done\ndata: {\"type\":\"response.content_part.done\",\"content_index\":0,\"item_id\":\"msg_028d7fb658c136b3016a5ce5b662b8819fa19ff40122f1c07a\",\"output_index\":2,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"},\"sequence_number\":12}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"msg_028d7fb658c136b3016a5ce5b662b8819fa19ff40122f1c07a\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"}],\"role\":\"assistant\"},\"output_index\":2,\"sequence_number\":13}\n\nevent: response.completed\ndata: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_028d7fb658c136b3016a5ce59cd0e8819f804427824478bc8c\",\"object\":\"response\",\"created_at\":1784472988,\"status\":\"completed\",\"background\":false,\"completed_at\":1784473014,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5-mini-2025-08-07\",\"moderation\":null,\"output\":[{\"id\":\"rs_028d7fb658c136b3016a5ce59d154c819f85755db041801f6a\",\"type\":\"reasoning\",\"content\":[],\"encrypted_content\":\"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\",\"summary\":[]},{\"id\":\"ig_028d7fb658c136b3016a5ce5a91890819fa161dd35e5e7c1b1\",\"type\":\"image_generation_call\",\"status\":\"generating\",\"action\":\"generate\",\"background\":\"opaque\",\"output_format\":\"jpeg\",\"quality\":\"low\",\"result\":\"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\",\"revised_prompt\":\"Simple flat solid black triangle centered on a plain white background. Minimal vector-style graphic with no shading, gradients, outlines, or textures. Triangle pointing upward (base at bottom), crisp edges, centered both vertically and horizontally, occupying about 40% of the image width. High resolution, clean white background.\",\"size\":\"1024x1024\"},{\"id\":\"msg_028d7fb658c136b3016a5ce5b662b8819fa19ff40122f1c07a\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"}],\"role\":\"assistant\"}],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"in_memory\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"medium\",\"mode\":\"standard\",\"summary\":\"detailed\"},\"safety_identifier\":null,\"service_tier\":\"default\",\"store\":false,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":{\"type\":\"image_generation\"},\"tool_usage\":{\"image_gen\":{\"input_tokens\":67,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":67},\"output_tokens\":196,\"output_tokens_details\":{\"image_tokens\":196,\"text_tokens\":0},\"total_tokens\":263},\"web_search\":{\"num_requests\":0}},\"tools\":[{\"type\":\"image_generation\",\"background\":\"auto\",\"model\":\"gpt-image-2\",\"moderation\":\"auto\",\"n\":1,\"output_compression\":10,\"output_format\":\"jpeg\",\"quality\":\"low\",\"size\":\"1024x1024\"}],\"top_logprobs\":0,\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":{\"input_tokens\":2853,\"input_tokens_details\":{\"cache_write_tokens\":0,\"cached_tokens\":0},\"output_tokens\":1256,\"output_tokens_details\":{\"reasoning_tokens\":1152},\"total_tokens\":4109},\"user\":null,\"metadata\":{}},\"sequence_number\":14}\n\n" + } + }, + { + "transport": "http", + "request": { + "method": "POST", + "url": "https://api.openai.com/v1/responses", + "headers": { + "content-type": "application/json" + }, + "body": "{\"model\":\"gpt-5-mini\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Generate a simple flat black triangle centered on a plain white background.\"}]},{\"type\":\"reasoning\",\"summary\":[],\"encrypted_content\":\"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\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_image\",\"image_url\":\"data:image/jpeg;base64,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\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now make the triangle blue.\"}]}],\"tools\":[{\"type\":\"image_generation\",\"action\":\"auto\",\"output_compression\":10,\"output_format\":\"jpeg\",\"partial_images\":0,\"quality\":\"low\",\"size\":\"1024x1024\"}],\"tool_choice\":{\"type\":\"image_generation\"},\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"stream\":true}" + }, + "response": { + "status": 200, + "headers": { + "content-type": "text/event-stream; charset=utf-8" + }, + "body": "event: response.created\ndata: {\"type\":\"response.created\",\"response\":{\"id\":\"resp_0a372a7fcba6b284016a5ce5b6a12081a1be0e5db6b7067a0b\",\"object\":\"response\",\"created_at\":1784473014,\"status\":\"in_progress\",\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5-mini-2025-08-07\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"in_memory\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"medium\",\"mode\":\"standard\",\"summary\":\"detailed\"},\"safety_identifier\":null,\"service_tier\":\"auto\",\"store\":false,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":{\"type\":\"image_generation\"},\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[{\"type\":\"image_generation\",\"background\":\"auto\",\"model\":\"gpt-image-2\",\"moderation\":\"auto\",\"n\":1,\"output_compression\":10,\"output_format\":\"jpeg\",\"quality\":\"low\",\"size\":\"1024x1024\"}],\"top_logprobs\":0,\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":0}\n\nevent: response.in_progress\ndata: {\"type\":\"response.in_progress\",\"response\":{\"id\":\"resp_0a372a7fcba6b284016a5ce5b6a12081a1be0e5db6b7067a0b\",\"object\":\"response\",\"created_at\":1784473014,\"status\":\"in_progress\",\"background\":false,\"completed_at\":null,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5-mini-2025-08-07\",\"moderation\":null,\"output\":[],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"in_memory\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"medium\",\"mode\":\"standard\",\"summary\":\"detailed\"},\"safety_identifier\":null,\"service_tier\":\"auto\",\"store\":false,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":{\"type\":\"image_generation\"},\"tool_usage\":{\"image_gen\":{\"input_tokens\":0,\"input_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"output_tokens\":0,\"output_tokens_details\":{\"image_tokens\":0,\"text_tokens\":0},\"total_tokens\":0},\"web_search\":{\"num_requests\":0}},\"tools\":[{\"type\":\"image_generation\",\"background\":\"auto\",\"model\":\"gpt-image-2\",\"moderation\":\"auto\",\"n\":1,\"output_compression\":10,\"output_format\":\"jpeg\",\"quality\":\"low\",\"size\":\"1024x1024\"}],\"top_logprobs\":0,\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":null,\"user\":null,\"metadata\":{}},\"sequence_number\":1}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"rs_0a372a7fcba6b284016a5ce5b7334081a1b3dc47c8448468b6\",\"type\":\"reasoning\",\"content\":[],\"encrypted_content\":\"gAAAAABqXOW3-Ow65f1AuZG4xw3IiCYm7EJ3ZPb6EqPBPK4wJeupE3cVGXIL92CKC2MMXvHbmV-LtR6csxDXJ7cOGOHD_KsKBJsnuDn8oBaUn56Ba2JqoVtEhHs3RDioGAB4fZp01cvBOiikRTzH1XYTpb1_4tR04nI8iO2pH5Kd3MrW5zYUeIl_Y9OdBTlJz3Mqxi0WfAIz4TY37_f_UaGJJXS8K9xu4fQ8Ef_poPHJVxWHiyZBiEh2FwPe8yoINa8Pu5_PyV_GfE--ClAfRTAhNZViOH2ne0Cg_oBtrRMVp9S9ql1Qx-IzWTAC38qh6tuhPWiAkrmPXUgN6BYaSK1S8z_E-Nr_51C9Q38uR2NUOEnpmeKR0RUjWEQC-cZYLQ19yTcAlfrYLccJSOPmp0R9h4GE8NvzB_HtvknArHZVaLxAOWrAwyGE7m6SGPMiVQqanAR85J3kFcZ3CMZlw4Y0u6rbYp30TSimarggY5epmeLE-1FC7LzgWRRvxTKS4N29mbUKoCPcXPyC47zR2OuHdV41Fvtaw-5oFutFU8WG0JJqF5jIt9WAvB4teei5dMdVRPo2iSGgvGrAYYjaOBy_P_XOPgp1woPy6_k6AzEhRuNzhgieMc9ZGUpNhIoge2slx_2WQKsjKnnqRjyAMl7e5EvelRoHpTOG0mDPxmqPDejoFiRGqGh2g6NM6-4KzOkZq7J5D455VN9OE_i0owr08zFSVfP5xlkwO6ByfHeSazzjQZjat3MLPzMKlIUAIzFNdvqO0ZwMCqiEQkQSN6tG9z4EDFUZddDjtNF0ncQg-VfTYZjV7r4fhKDJQKFhXRzgkHyyu_edb1mM5dd19-fzSV8zd_ZfgW7n_SgRSFqhrlE8Tmpi80gM_GPdn6UJ5oYC9q5CvdpR-sZ7kSOwcDTGDi3Jgt1r2hudc3CtAADTFf95O_-LnUg=\",\"summary\":[]},\"output_index\":0,\"sequence_number\":2}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"rs_0a372a7fcba6b284016a5ce5b7334081a1b3dc47c8448468b6\",\"type\":\"reasoning\",\"content\":[],\"encrypted_content\":\"gAAAAABqXOW_JvNgvAr5mn5PqUudddAgMyL5Y37NwUV08gViStnE2hTne_KD9RB37hjzgSapdlCHawySV-S891qsw7g_RdaTeDW2oMZe2xjCA5_A1Gw0xQkzVl5fBS7TgW6cycbIGcrhPf1_z43vW2LOF4WFHAyzUhEc4gCBvXHs7iT2yeY9D1__xDQ5Bxuk8wxyesB3AwdR8UXQvdf0o9G-etykqcE-ZOMFapaDgNNFg2MSxuRMNjKnn_aRysRTtS3d3BCjzp8cbLCyB0nMSyfef7a7AnPnGPrxe7L5fg-h379tK2qK2D_-806o4BGrywd17Px3jUuXdob2w-daHT2xqzBcih1wEIuNOWsYTo9Db9NwM72VnwENpqZ32F7peWoQhn4C9Z3NGgvpK93szF1Hq_Fn7j1pcfYRCXzjz723GZdJow1bomxPqYdnoPjs1sRMpLxutxwbn_mRBe_cK5R7BsYL7GwR9ATwucIVEup93Wv091ZNmUP0H1H7jAkunGJHpVE3lTYK8wurfrFHHOmkOO9yTVOxQfQh4GgiYKle_Jsj7E7FKMpwDRvRchGa3T2FWXQMqscr7NYhLwgfPEzS-O8wsmr1KRVzzrlwSd85ejX1jZ4vYrS_fZKRGf7YrovxRUaZQOddNdayeFkLXTUIEUO8J69KokM8JOq39HbiDYxJbSUtlPjscBkoEZlURudRednd6Ov9WsTogwwjosuFbKNnNL0vzWpYODeGsgmz2dvTS4SM70XQ3tZhCulIUGeduJxPs9JdWdGwlODUoBg5foeL8HguxQ2yr2HbJf2pVoHVE0WjY5MOHT28uFkOuEWobLEkKPtxrQvelUiRK-dFk2I7Bs7XIABh0oe_ekZT5bgpsOydrPxidcjr_TRnVocTkLYPEo2QJf5QbhuC5i2L6wCdObazF9dNihKPb9LpPLH7NMjH5GAS1T-FwD9EHM-oG3DrSvYdbRHEKTlOmgoK5PmAuDzZtXOuoraLKD6OBw2cXmU1UlhBbSrZkHXMyApdQXy32o-pKI0QBqK6ajzSypsQex6zwV-QomPoLEuhIINcNVlOZfMeK3MRyLf8SmzYwAokhI-SVvix-Ev7UR8fHagS26OEb_AG4ttGxZiODPCAiNsJROzGj9LjusmaeFXuNlKj9evZlRTDCrA6hCwWPMAei_TzPpG_8TEceTwzb2acNE6SueKMb7lIqFU2kXsQngD4h7Uo-rGWL_THN5Vg75mEeCqh2xiqMsLABY-w3v31s0p5hxgn8bhLLlS0cWfAXZ_LtUs3JlAMDzncybYY6Y4eUAln98r3UigxWFzwxzxfJukJ9Xr74WA3L7T9K0RBb6cC5OiWDjXfbcNmZB0sN48dUMVyp6w_6YAWAKWUuBMO6sBBxZ4A40ZswXHpNlOzoJPV3Zf70kpFI-G-zsdcPB21JSuYxOUthp24hfn5ywkbQPeNSAgi7PcI9rJaSryeJzRgmWmDmYFC-XMOEbe-tD_zI3YqtekaBWq9_oXXzZe3FfbvUYWeCYJYp5ODNWGAHr6nt22AJ-mG0nIdGDUmVZbWfnhXyX5gUyWpdcVbe8i2ebGtPu8rDV4epC9NL4Sy6lvOWms1hc4Nja_uynZb4QcAqoYzP5djPEzTdemtZmhbODMG-cC0ymYhwNqjG29Kpv_PoYx-d0ZQbpFntDPUeb65H9WdX9wZqKmZLpJ5y00TMCZ5lGpb3pleyASAfSJoRcp6dQN4FArtb-LmiLBNpaZVOOg9m921ncZ7Gg5M9cqv_fnvkQPbtDigzu0TDTUMAjNzDRY2TyDC4-XhHYwmvmptAVLHmR0KunAzd4Td5fEQjblRP6G25Tk_jOZSIdC9mATwY_FdXnPfQYPw_fkDWGdAAy3FXkuLUAXZZUU9K_CxyxmC4UNS0k_yslwSdWMmMl_nFDT8CIpYc8aRrJlNU9RG04i0V1QSuZ0lmJkprJsqga9IRz5tLRdIJ9fazjsaLU8scM6JRkbEMf30HpbpWeRSMk097SmsHJqSx0GfmW_n3q0JGAPNVO3M6fh9L0I9kuaOWYg6uLJm7sWs_pamjlLMqJOvN2j4RxGc5QkF7eN3wlPuV7YkWDHU1ntGDzH95f5NgVTjXVTlEuqI5obRO-DdK82xdWpS-jTMMoqC7tiPMS5E8zHh_cAWldXcrWN5kOVJLJpn-n4WFC_hzf8q4uC3uarCALwmzIiA9bYEPS5_Xw0j6bFgLeEcynrFvmBjVEG3AVUParj-9Goc4kRply59MRHZeP59mZvn8wqT4HkGyNFvc3ZUfZrKr2Xdv2gZsMRx2D8vd0K6O6N9ihhfuk7lmhizSrIeHw_fuC_gzSrj-oYHmcLIQTTz9W5sgJI-6z-zskL7wFkV2vWiym747JTLG6p8GjQQeQ5pVOw2fDuYQSq5_ZzmMdJlU2dNg09CuO0fR9Zek9mgoefgXplh0-o3rGiaLreGL51Mxe1OGVlcolzDYw_IXeS4SYv6jh0ak_oCvFLIEM6y_BXx_bO3tk_R9BD6f3TO6IMTTuSLlO5IymvH-rTmuhqH2LVCDdSbCLSQ1qUAudbvomaro2CCD_bBJgqafe-x-DXWsuxBufEqqjl0g-oFjYRnf075VhGz-JqFAaOFcVKarF6K7srK3h3geKztlwQdt3NLl4wL5NYWMZ6yYloHDjh6oB2qOX9m27hD6Al4aW-X5r7aVekuDHUIF3cW3Isvtj2xeoKBqc-8l2tmKrvGmJReeWa0wf1MgHxZGjvSN-EvhCNsN40cZm6bdxVijQlPsHE83qLwN8SmVBbbWkp3IXEsLIDk1Ajnea8yi_MiHtHbOqXOFbc3W9Na-hOBNcmA6KruZkLcLULCHatVKhfreqBXQOzKnO_mHrOA0ORyiB6IXK-01DRJ-OUldKZrZ2KehkV3CtnT2y6P4Up8lXEZ4aKYyboEnmDUqJTuwO6_-b65b2qP6Gs3VPUCv8JQ3Q_uMcvGy_cIpd_xsi2VNf0k2hskpdRLJBRhULKQQVTYtYEanHatZPKQj2l6PFHQWCDnkS815BpEeNAIxecfAFElyxn21J4QIE53G6yJBC1wYgBlKXI1s7pOABdcQqBI5P0zBNRZqFUFPO83EIwCRAjGHCH-KdtFPmCB7ZktwEvAHiF0rnaMnpxdHFo-Vy_JjJeaOK9cvV6P24knAza7SI99xN5eX2euuFH7pQC6N7_TH3ZCHkm_oosUiPVJU699OmlIpRMXJNksqtQfhGOb0HjhkhHbp3xt4HfAq5XxzKqcLVHc8lNAsumN29kEOpuC2TrW9UdgF6pAXZ-xFaAPvq2VNdaHjwCpxwEq3GAu8vMHwV9Rx-j6cB-Ulr-WH0wKtzvhsQnhPYMA3lTmCJfw_mez4ji1UfE_yeHKZwTR3KWrbi0L4ZpqqIs6oCleoGOE1rAuugk9n3LRsbAdGDjdf0jfo6IDupJIXOHtVF2uuHA_hwcpehbm30cMSzEbgfA3u5F4v7EgL6AEUiB67jIJRgQJ0mlWds_r753993yqdWMziOHcIXu0ChXv23zoyIqdcLVDguVA6cBW7Dkg71ZnOby2rPSB2r_RODwvc9_S62rIP17X1B8JpVQFscKN8qYxT66PhTLXukKM5HmzAnHTRnVUB7p76YKqESBRydt_1RZduxcHpDjuz5ZNSLh0j1JfTDmNPuEhJioGDeGBug_OzqV_rvmKSrwNXj61piaWKm0FByuuEB5X8kfFnvKwxttyiYZz0NPHZPFyv74UNGLOz5yCBMkMLIY8a1eiNC4VTZt6ppHRyIT74TdA4OCCLTID6_npt5gt66WpCXmi0ag8jEYf0ZoLqJEMaIPG3pAHkts16FxL-s1wlbIsVdcGOtGpINXj8d6Oe6Jdrlgeba0uNfasigcmoFsIvLVgPJ_X81-QM3LFR_0ANFNNWbTf9C0xZNy7x8JjMmTBbaBot-I7q7hodrCprqdDJ5kYcgbK1kbJDzN584Ojp6GILovMfeDyyjWaUSy5g5Ju_LFo0OFks2p3s5v9Wg5Z5q2Z5-bf3z3nuASZR6axMC2PGdch_NTN8NPAh8C-njKHXA8z62m5dy9kJNPzCqbaNqySAxCW_alEYpPW2IaxmsqgfNrupl3yknSpxFR0KZGOgDRc0JndrAj859XWhFj3tNZwIdJjHcEwhFZcpGNgrBEXSy1kC24Di6GJVnB_XIP6rSp5kCqH672eBqZ5FLaKYoF8JOIZq0gdIoKv5Ew-5LgJnZZrXOyKs-Q4uDtg1q0ToSirnYKafmwcx7w0wz83lZop3IJ1DSwxoDWVfgn5UzPfeRqehIqJx2daGJFaml3A76BnjT3YY-UUAp84MZLlx5FeXlzYvqK3Qi5I5RzHpN7P6NUibJM-i0G2ejmS3nhQdlqn2m7nlU6-10VFDDPoZqaUMmWPDIkmXcrZifV_c56S7o63HevKAScwxrbjoivaF105RSg7DTCQwEgrfMzJZfbT0NKyx4ZLrZ-3nA3JLhAGHS5l6PoBCJUL6_ZNq90hXI8nRVmam6svuoZ9H8kjsA3xP4mTYNLh2PfU_i6GrMUTmg2O9Dto994ggh_j2zJgP9U2X3D5WJrWJHP1IeNIS2YDgoDDtTs9mj7tKF4EhcWDlpihJmkJzFJZJ3RZ761Fa-B6DsxH5-4vesns_kGEhCNFXTjjjNmc9y8PTfjcgqVHnvoabRXHXaDQROZkPHNqf69y39FEUxjePW63mk-MeV7vcYdmlgxfdhyX-GoycoUPPpY5yVUez6auomjpB9hcUVdPXUE8Szg=\",\"summary\":[]},\"output_index\":0,\"sequence_number\":3}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"ig_0a372a7fcba6b284016a5ce5bf22e081a19e660657ce98596f\",\"type\":\"image_generation_call\",\"status\":\"in_progress\"},\"output_index\":1,\"sequence_number\":4}\n\nevent: response.image_generation_call.in_progress\ndata: {\"type\":\"response.image_generation_call.in_progress\",\"item_id\":\"ig_0a372a7fcba6b284016a5ce5bf22e081a19e660657ce98596f\",\"output_index\":1,\"sequence_number\":5}\n\nevent: response.image_generation_call.generating\ndata: {\"type\":\"response.image_generation_call.generating\",\"item_id\":\"ig_0a372a7fcba6b284016a5ce5bf22e081a19e660657ce98596f\",\"output_index\":1,\"sequence_number\":6}\n\nevent: response.image_generation_call.partial_image\ndata: {\"type\":\"response.image_generation_call.partial_image\",\"background\":\"opaque\",\"item_id\":\"ig_0a372a7fcba6b284016a5ce5bf22e081a19e660657ce98596f\",\"output_format\":\"jpeg\",\"output_index\":1,\"partial_image_b64\":\"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\",\"partial_image_index\":0,\"quality\":\"low\",\"sequence_number\":7,\"size\":\"1024x1024\"}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"ig_0a372a7fcba6b284016a5ce5bf22e081a19e660657ce98596f\",\"type\":\"image_generation_call\",\"status\":\"generating\",\"action\":\"edit\",\"background\":\"opaque\",\"output_format\":\"jpeg\",\"quality\":\"low\",\"result\":\"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\",\"revised_prompt\":\"Edit the provided image: change the solid black equilateral triangle to a flat solid blue triangle (use color #0000FF). Keep the triangle centered and the exact shape, size, and crisp edges as in the original. Preserve the plain white background (pure white). No shading, gradients, outlines, or texture—flat uniform blue fill. Maintain original image resolution and aspect ratio. Ensure anti-aliased clean edges.\",\"size\":\"1024x1024\"},\"output_index\":1,\"sequence_number\":8}\n\nevent: response.output_item.added\ndata: {\"type\":\"response.output_item.added\",\"item\":{\"id\":\"msg_0a372a7fcba6b284016a5ce5cc22f481a18bbb28bae4f0ce38\",\"type\":\"message\",\"status\":\"in_progress\",\"content\":[],\"role\":\"assistant\"},\"output_index\":2,\"sequence_number\":9}\n\nevent: response.content_part.added\ndata: {\"type\":\"response.content_part.added\",\"content_index\":0,\"item_id\":\"msg_0a372a7fcba6b284016a5ce5cc22f481a18bbb28bae4f0ce38\",\"output_index\":2,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"},\"sequence_number\":10}\n\nevent: response.output_text.done\ndata: {\"type\":\"response.output_text.done\",\"content_index\":0,\"item_id\":\"msg_0a372a7fcba6b284016a5ce5cc22f481a18bbb28bae4f0ce38\",\"logprobs\":[],\"output_index\":2,\"sequence_number\":11,\"text\":\"\"}\n\nevent: response.content_part.done\ndata: {\"type\":\"response.content_part.done\",\"content_index\":0,\"item_id\":\"msg_0a372a7fcba6b284016a5ce5cc22f481a18bbb28bae4f0ce38\",\"output_index\":2,\"part\":{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"},\"sequence_number\":12}\n\nevent: response.output_item.done\ndata: {\"type\":\"response.output_item.done\",\"item\":{\"id\":\"msg_0a372a7fcba6b284016a5ce5cc22f481a18bbb28bae4f0ce38\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"}],\"role\":\"assistant\"},\"output_index\":2,\"sequence_number\":13}\n\nevent: response.completed\ndata: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_0a372a7fcba6b284016a5ce5b6a12081a1be0e5db6b7067a0b\",\"object\":\"response\",\"created_at\":1784473014,\"status\":\"completed\",\"background\":false,\"completed_at\":1784473036,\"error\":null,\"frequency_penalty\":0.0,\"incomplete_details\":null,\"instructions\":null,\"max_output_tokens\":null,\"max_tool_calls\":null,\"model\":\"gpt-5-mini-2025-08-07\",\"moderation\":null,\"output\":[{\"id\":\"rs_0a372a7fcba6b284016a5ce5b7334081a1b3dc47c8448468b6\",\"type\":\"reasoning\",\"content\":[],\"encrypted_content\":\"gAAAAABqXOXMPG3ar_yhYbV9hXMqlRF9LZiYy0K1DHVeRg3CJAgnN8f--ijiLuuT9tlPsJaWLvSoiGxqFtHaUH1w-Msm38QXa2G5XMQlPmjkfevSwLrVavxhA8DFTwR_7kL9FSkvpQgATEMk12TCCOPLR7aZZBQKdz9OZXyD2OKYi5JEhZ-8QRR3DIW_LUIoQv5wkNA77zJ_WouJyCrsJ4cYkB6_3jLHUUTl0uieEswXEsq4UP_v9ffj1CyHfHBNwC1hjRkoIb1aEzW9DncsyHJUn7V-2lNg7aPSqRGKNxbz9931nyjfLEjQji-QW9XC0sEtORhDSPMJzokvmmvAtbEcR8fECguFiOz4SuSm3E3WbHfrvdAJKa5i4NpLluXpDRsRsb-L6O22BeU90JEJe69XLAC1nM7fp1W9mKxrHoplX1w0EzCfuSjvUjMO1GoTifVuBKOuwiry6NykzmpiiXVmej4qKX4o9K_YKN2QOK-u_f576lHDxDqHzeAz99bcqXVJtm5yDq-iIsOrg_CYpu0829lelz8mfgkK0426Icg3gzq09qWIZm7ly_VjOlLiqQJyzML-n20OzQBHXzYupeeicbx-qpxpxHsE6E5deHfSg-hKyLaBVLCIomd2V-EiObFW9hGc7HwMqz1ZGucNQ5hJtx-DxNzKG0z79vrvWo4qiPzsakHWL4AuhiPW4n8thbvLirRPDr2GOqBWI2wFySuUrMcceTxstivM2znrHEUcrbP19LI3y4cKQqHRwUUktxlC4vj99QApKsw26jNm-WQTuADFjYBYuEKLF2akU9Y5mvA3czEtK5lXFnDcUNwOB_Xn-va10N-g99e2pbm6CTXZjP0YjhnY5Ndx5czvksKhZabbtK4_pj3ha6NVhd59-erGAqZzJb6DuCbTwqw-HRa2gXIE011tOpGAbxp4OovBod7hDXOiJVk_qpEnjlxlZG0h7fHNVxU1Kf2Po7-VBo-4pPqU9pjG8Rk6TKqawlZ7ApZgMilUCEx4tVgiRUgSi_VgCA8X5_iW7ng24rfQ3PXUkm8Zn0Z860SJLRhsm_QlvzoJ3kXPmjOEcYI8gKtIjCzxpuu9JRZRBP4KQee3kk-yoQv0nTehVeTOCFbCRQ8xg6FwghAEEw9t6lN9spnDi9-S_mXgm9cezKFxQ1ai78WvWWTl4-om8DI0Qb82IxqASDhGPTgOX-bk8bXW-A80QXmbJm1aLDyKPztZ1jIWNY5Pcctba6nFK55ckd6EE8FptExQ-oTDsBFd_zbAh7DgA36ge9ZBXfMZ_8uhndX0YgWuALXfkP9XAfmTb_U0QJsSuk_7uKJ0TRgNBrIeeI90WRSwoDARh8wL-PLP_cl0u2tZGPHBo5Up75x_S3CX97jJ8_wOnzdwxbc-SJmBQ1FHRrib6s-7OT4IIpMunDb6cgqcE3kuazHG4sUqSD5k4CqvWl4lcc6DNtot9zJ3mXl-o1T1DfWhpa56kXkvC5DJwkGjej_ZeMeacHOKCXQwLMEMNheeRy-0_FhSH1ish-s7nwcLmWhZz6p6YVffFTTcHnKaFuYCcXPMDXcym1PFWJjxjwFJYTOOahtsBrVMx3Q1Hh7gZ83i4ND1JR7ezZp3Un_Gt_GnQL84QYYmqvordDxFh0mXGXXwza9ErAdco29q75qb-y-edT8OFY3VoPHCV6jgFUA8LgkFaI7-1mxoLBdHeflgxIcLoCFlsrCiuKtk2GDDIgIIeALA1JK7ePmsgSO-3nsHI2eMwpPdDHE8S4LnuY_e8zGw0T8xRN9STH6ug7dl-cNM50zCs4dPAaJXhL-tW33wjhuThxR5B_3j7keygP6k1pNNiyGuOUhuzGMHxKbhvmG_wD-fGT6hA3nX0d56JwqYYld8O6yQloBrDjJMSnshRHFg_FnCwboENZD0TTbKe6-9Y3L6rX_lWzFlsWWGTKjJ3fzuBrNfMunqoJOsVwYfmaECu5Wc1SuMpP6MWkn-J-pQWTT_b-SSDYCnok4xN09NgCCrtge5tDvnuwbeKeqNDLYlcDT-jxxFQN7R2PGbXxXezz-KJJxLzZxD7ImKN4WSDNXA__KaFgZ1S-icgSK2OjqwzqYi-onuluZPJguhRSsAEqmh50dQctpz6sb1UVgvzveCluuUuA-bveQ3382Vvmd01d35yRmpwHdxgnasJPq1hoG96qgORgAUZ6C1F4QyQRUvaO-XWzctSqOJKkcBdyfcKFjYOl3sCmR9H6NTEDhMkwczfEf4oET3W0kTEKlrhdHrp-02AHwmlNaCdoPQuyY4o86PSFZFwdvGdabBnU3K_FBr9UCURoRkZJRxeexBffWCFYTMSLFtFV_ZEXprLgkgb6LjybZ8srLbMgHE5AwqRUFMx_0kFmoMGN5OeKca3rIFsG7YURGsdaN6s22OLu_sgpk-y1S4fF6Cyy_b4AwiYRW4tzdkiQ11saUlI4q1_bPFhAtJ2_Fw9r6QSvViGgZFujXIMwral-8Nv1XZdT6w8ia-MLtb69eFiIq8wvnHgJfroeAbMZoF6CyORTWw6iM0ytb5sjSv28t28o-3X_r4zKjW4n-Q2e8ebiDRTsj0N81qGnmGtkzG4WmgQ116kQKiBITq2Gm3_HtTmLSKnz5OB505GF91NqDk-gHJk-1lC5xzCopnMdujJ2r_JrnysiUPRt4jwr2UJ5ZuhdUXNTVxuTO4OXhguZLz_Lb4Jzl4AEtoj8kr0jUwaddWyQWOFMjO2Oa5OSmP55nEkkZyHVa__0eT1UXAAWNOHn30doiyOQEuxh94d-Vhu9mTL0ftj12DKbb_f4vzNZtkkzxnS-e7-EL9STHwBiJlAJnm4sZTzoHOf88HJJfkCSPXkVdBHKKRiI81-jn2ZEAER22m02DzI4Mh0Ewdw9Wj2r5n0HZkKBI4TNiUqI-WKlptYhaJOwpa6zeMFYGF8_vah9wy_ef3APb623CF7-NNqJiQYdqq8auGuBhhRYCnU1ASwiWaOHVh5WkLwsTtKvHDAidTCUCN5e-Wm-y46CcMrmxUZZ2_498VT-iIplOuGig5aFKg9tzJwahpXlxAhxoyEXjxeG_ND7tgXS1AwORwvtiIOlv-J0pnPbw0U9UXXamuIZX3_xsaVil-JMDC_0Ee7f7klD0gUyeFBp2ZuaancXmqv58kN3m6fYGM1zxDGr_a25JJWGgowQ35PZt8tYWioAHCArqgYoCbV-uk3Gl0Y_PXc7kWIauhHbPXYJNYjm50u5TUwBo8MZA7TGZFFSLo1s9Eb9E-AVtfuA5Ag1A8e31yI7ifygerhIcaV66IefiSo0nG9LBdQBeLu-p35TvcPb5acfJdYUTmQ3Ans6UZSsNONgA3Yq0HdUG94_UWSS0FCetHrKm-ajS2mJ4ZF6MQ8ozGz2VN-_0OkOPgdniiVAu3F9gkKPGtjTQgjxtrgvkKvXgpnSMlTuDxAG8jLNRDZEVFNOg7D-27DDJeeAJhGlnDy2jQsq5D2szI4H7_sEXEIgcNqxDuzq3uKPagjFQM4Dj1BIKn3havdKzkQASGSdz1XoAvmDvUnc0zkIH6rZLp-tq4pS5LZCS_P8Lhcbjyb-Cw_DZi8iCuN1NfCmO9VFtxoUQCSkrt1e9UxxYcSPM1mugbsj4uo-6LVIe7uKcZ3VMjaerj-wNJmn0q9y60vlQL76JZOravQL1arK7CkqTKOs0YpkEmwBZkdBSbd0oRKNPoHkRuxQ3OpzSS-P-ZsP9rhqDK044u8s8X3K00DwF53rLvJTrRZYfzf7hymRYBjlXM1DQ7hreOqlFVBlOfv8Z7FaIVB28SIfrTB_GzmKPqy0FvxkwHGnLA8MLgGSxtxeALn0bxZblIiMtMG3xp7ZsmFInQ557YJc2itiTMdOg9UAKwsQjRe5UizldmKUUaVzfMlKWO5fCewHQ9REi9A3xx1CHLKr_IjSiRwSfbmkmEn0BJqkooAm2Lg1Gh9_lgDmPz9_kI3_aGn2pxyX2R85JElpeB4V-Ze085wrAq7mFDAP1XGai8FRxu0yZKDiCT_tjauLzs1l-SwM-tAZwzDOkogfFs7Hi8jVk3P58KamUVsua4mG-I_pfSgmwj3kkRgfN1ms_i76Yix8eVppxCnYXaiA4RbXXYtH0IEs6Z5V-W-4UY_ycKxjvOLxBqArXqSWX952-JYht9r1L6bP6jdV-V3l9P6McTAcjiOKaOfNuRN0AW1xfOGbaCAgb7bL1Ji-KrZfFpcFHvzyzkIo5kUikAc48ZG3Hp_voOE6YGTIcnhyiZSm9lvQKLigiT1f6zp2yKkCISsYN3twoYpDr4ZBicbFIhXav2fn59dtNfypTAPY5YEylch2--u3-7NEmIauzbqW3lIetzBAaRwlX_ZQHnx2eA2l8TM1cOIuOeJjQxweRR2LMNTQZMEwPsx3DYfCbdkJrPusXJuZ_QLoumDiF4tiHutM6spdPALnU9wGsfecce3-UW_6Xhp64hTaELYrB-_2kqhECY4PGPbwGZg9lU1AYeR-ibTJvrDUXZnbktxYXPXlyudxedWuIjPTCD_0h1ZfVgZAaSvMLH3kQE4h8kO4txZtJG7M5tc3zJQZJDjNY8LXSxbEZTQqTleD4TSZ7Uia7H7wdz4Jdc5x6cRm89aVFtmDJyCyiXgwOwppvnw5LGEsmfVAdmmIaoYd9u5WNTrPBgGV8_aiykflmZnD1enJToj3EvhgH3KKePqvjfg8ay61Q1A0f5PlqCe9knA6N3jGRM3IoB_s-5Rp9cYMF1jLCO7n9HB40t7W5mqEBTO-Qn55TF3os=\",\"summary\":[]},{\"id\":\"ig_0a372a7fcba6b284016a5ce5bf22e081a19e660657ce98596f\",\"type\":\"image_generation_call\",\"status\":\"generating\",\"action\":\"edit\",\"background\":\"opaque\",\"output_format\":\"jpeg\",\"quality\":\"low\",\"result\":\"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\",\"revised_prompt\":\"Edit the provided image: change the solid black equilateral triangle to a flat solid blue triangle (use color #0000FF). Keep the triangle centered and the exact shape, size, and crisp edges as in the original. Preserve the plain white background (pure white). No shading, gradients, outlines, or texture—flat uniform blue fill. Maintain original image resolution and aspect ratio. Ensure anti-aliased clean edges.\",\"size\":\"1024x1024\"},{\"id\":\"msg_0a372a7fcba6b284016a5ce5cc22f481a18bbb28bae4f0ce38\",\"type\":\"message\",\"status\":\"completed\",\"content\":[{\"type\":\"output_text\",\"annotations\":[],\"logprobs\":[],\"text\":\"\"}],\"role\":\"assistant\"}],\"parallel_tool_calls\":true,\"presence_penalty\":0.0,\"previous_response_id\":null,\"prompt_cache_key\":null,\"prompt_cache_retention\":\"in_memory\",\"reasoning\":{\"context\":\"current_turn\",\"effort\":\"medium\",\"mode\":\"standard\",\"summary\":\"detailed\"},\"safety_identifier\":null,\"service_tier\":\"default\",\"store\":false,\"temperature\":1.0,\"text\":{\"format\":{\"type\":\"text\"},\"verbosity\":\"medium\"},\"tool_choice\":{\"type\":\"image_generation\"},\"tool_usage\":{\"image_gen\":{\"input_tokens\":1116,\"input_tokens_details\":{\"image_tokens\":1024,\"text_tokens\":92},\"output_tokens\":196,\"output_tokens_details\":{\"image_tokens\":196,\"text_tokens\":0},\"total_tokens\":1312},\"web_search\":{\"num_requests\":0}},\"tools\":[{\"type\":\"image_generation\",\"background\":\"auto\",\"model\":\"gpt-image-2\",\"moderation\":\"auto\",\"n\":1,\"output_compression\":10,\"output_format\":\"jpeg\",\"quality\":\"low\",\"size\":\"1024x1024\"}],\"top_logprobs\":0,\"top_p\":1.0,\"truncation\":\"disabled\",\"usage\":{\"input_tokens\":3510,\"input_tokens_details\":{\"cache_write_tokens\":0,\"cached_tokens\":0},\"output_tokens\":669,\"output_tokens_details\":{\"reasoning_tokens\":512},\"total_tokens\":4179},\"user\":null,\"metadata\":{}},\"sequence_number\":14}\n\n" + } + } + ] +} diff --git a/packages/ai/test/image.test.ts b/packages/ai/test/image.test.ts new file mode 100644 index 000000000000..6ab4a72d421a --- /dev/null +++ b/packages/ai/test/image.test.ts @@ -0,0 +1,95 @@ +import { describe, expect } from "bun:test" +import { Effect, Layer } from "effect" +import { HttpClientRequest } from "effect/unstable/http" +import { Image, ImageClient } from "../src" +import { OpenAI } from "../src/providers" +import { it } from "./lib/effect" +import { dynamicResponse } from "./lib/http" + +describe("Image", () => { + it.effect("generates images through the OpenAI Images API", () => + Effect.gen(function* () { + const response = yield* Image.generate({ + model: OpenAI.configure({ + apiKey: "test", + baseURL: "https://api.openai.test/v1", + queryParams: { "api-version": "v1" }, + http: { body: { deployment: "test" }, headers: { "x-default": "yes" } }, + }).image("gpt-image-2"), + prompt: "A robot tending a rooftop garden", + count: 2, + size: { width: 1024, height: 1024 }, + providerOptions: { + openai: { quality: "high", outputFormat: "webp" }, + }, + http: { + body: { request_metadata: "value" }, + headers: { "x-request": "yes" }, + query: { trace: "1" }, + }, + }) + + expect(response.images).toHaveLength(2) + expect(response.image?.mediaType).toBe("image/webp") + expect(response.image?.data).toEqual(Uint8Array.from([1, 2, 3])) + expect(response.image?.providerMetadata).toEqual({ openai: { revisedPrompt: "A precise robot" } }) + expect(response.usage?.totalTokens).toBe(12) + }).pipe( + Effect.provide( + ImageClient.layer.pipe( + Layer.provide( + dynamicResponse((input) => + Effect.gen(function* () { + const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie) + expect(request.url).toBe("https://api.openai.test/v1/images/generations?api-version=v1&trace=1") + expect(request.headers.get("authorization")).toBe("Bearer test") + expect(request.headers.get("x-default")).toBe("yes") + expect(request.headers.get("x-request")).toBe("yes") + expect(JSON.parse(input.text)).toEqual({ + model: "gpt-image-2", + prompt: "A robot tending a rooftop garden", + n: 2, + size: "1024x1024", + quality: "high", + output_format: "webp", + deployment: "test", + request_metadata: "value", + }) + return input.respond( + JSON.stringify({ + data: [{ b64_json: "AQID", revised_prompt: "A precise robot" }, { b64_json: "BAUG" }], + output_format: "webp", + usage: { input_tokens: 4, output_tokens: 8, total_tokens: 12 }, + }), + { headers: { "content-type": "application/json" } }, + ) + }), + ), + ), + ), + ), + ), + ) + + it.effect("rejects invalid common and OpenAI image options locally", () => + Image.generate({ + model: OpenAI.configure({ apiKey: "test", baseURL: "https://api.openai.test/v1" }).image("gpt-image-2"), + prompt: "A robot tending a rooftop garden", + count: -1, + size: { width: -1, height: 0.5 }, + providerOptions: { openai: { outputCompression: 101 } }, + }).pipe( + Effect.flip, + Effect.tap((error) => + Effect.sync(() => { + expect(error.reason._tag).toBe("InvalidRequest") + }), + ), + Effect.provide( + ImageClient.layer.pipe( + Layer.provide(dynamicResponse(() => Effect.die("invalid request should not reach the provider"))), + ), + ), + ), + ) +}) diff --git a/packages/ai/test/provider/openai-images.recorded.test.ts b/packages/ai/test/provider/openai-images.recorded.test.ts new file mode 100644 index 000000000000..71734495f78a --- /dev/null +++ b/packages/ai/test/provider/openai-images.recorded.test.ts @@ -0,0 +1,40 @@ +import { describe, expect } from "bun:test" +import { Effect } from "effect" +import { Image } from "../../src" +import { OpenAI } from "../../src/providers" +import { recordedTests } from "../recorded-test" + +const model = OpenAI.configure({ + apiKey: process.env.OPENAI_API_KEY ?? "fixture", + image: { + providerOptions: { + quality: "low", + outputFormat: "jpeg", + outputCompression: 10, + }, + }, +}).image("gpt-image-1-mini") + +const recorded = recordedTests({ + prefix: "openai-images", + provider: "openai", + protocol: "openai-images", + requires: ["OPENAI_API_KEY"], +}) + +describe("OpenAI Images recorded", () => { + recorded.effect("generates an image", () => + Effect.gen(function* () { + const response = yield* Image.generate({ + model, + prompt: "A simple flat black circle centered on a plain white background.", + size: { width: 1024, height: 1024 }, + }) + + expect(response.images).toHaveLength(1) + expect(response.image?.mediaType).toBe("image/jpeg") + expect(response.image?.data).toBeInstanceOf(Uint8Array) + expect(response.image?.data.length).toBeGreaterThan(0) + }), + ) +}) diff --git a/packages/ai/test/provider/openai-responses-images.recorded.test.ts b/packages/ai/test/provider/openai-responses-images.recorded.test.ts new file mode 100644 index 000000000000..41b9ab84d416 --- /dev/null +++ b/packages/ai/test/provider/openai-responses-images.recorded.test.ts @@ -0,0 +1,66 @@ +import { describe, expect } from "bun:test" +import { Effect } from "effect" +import { LLM, LLMEvent, Message } from "../../src" +import { OpenAI } from "../../src/providers" +import { recordedTests } from "../recorded-test" + +const openai = OpenAI.configure({ + apiKey: process.env.OPENAI_API_KEY ?? "fixture", +}) + +const recorded = recordedTests({ + prefix: "openai-responses-images", + provider: "openai", + protocol: "openai-responses", + requires: ["OPENAI_API_KEY"], +}) + +describe("OpenAI Responses image generation recorded", () => { + recorded.effect("generates and edits an image with the hosted tool", () => + Effect.gen(function* () { + const initial = Message.user("Generate a simple flat black triangle centered on a plain white background.") + const tools = [ + OpenAI.imageGeneration({ + action: "auto", + quality: "low", + size: "1024x1024", + outputFormat: "jpeg", + outputCompression: 10, + partialImages: 0, + }), + ] + const response = yield* LLM.generate( + LLM.request({ + model: openai.responses("gpt-5-mini"), + messages: [initial], + tools, + toolChoice: "image_generation", + }), + ) + + const result = response.events.find(LLMEvent.is.toolResult) + expect(result).toBeDefined() + expect(result?.providerExecuted).toBe(true) + expect(result?.result.type).toBe("content") + if (result?.result.type !== "content") return + expect(result.result.value).toHaveLength(1) + expect(result.result.value[0]?.type).toBe("file") + if (result.result.value[0]?.type !== "file") return + expect(result.result.value[0].mime).toBe("image/jpeg") + expect(result.result.value[0].uri.startsWith("data:image/jpeg;base64,")).toBe(true) + + const edited = yield* LLM.generate( + LLM.request({ + model: openai.responses("gpt-5-mini"), + messages: [initial, response.message, Message.user("Now make the triangle blue.")], + tools, + toolChoice: "image_generation", + }), + ) + const editedResult = edited.events.find(LLMEvent.is.toolResult) + expect(editedResult?.result.type).toBe("content") + if (editedResult?.result.type !== "content") return + expect(editedResult.result.value[0]?.type).toBe("file") + }), + ) +}) diff --git a/packages/ai/test/provider/openai-responses.test.ts b/packages/ai/test/provider/openai-responses.test.ts index 3bfe72da146b..e345cd59b1f5 100644 --- a/packages/ai/test/provider/openai-responses.test.ts +++ b/packages/ai/test/provider/openai-responses.test.ts @@ -1,7 +1,7 @@ import { describe, expect } from "bun:test" import { ConfigProvider, Effect, Layer, Stream } from "effect" import { Headers, HttpClientRequest } from "effect/unstable/http" -import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, Usage } from "../../src" +import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, ToolResultPart, Usage } from "../../src" import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route" import * as Azure from "../../src/providers/azure" import * as OpenAI from "../../src/providers/openai" @@ -58,6 +58,39 @@ describe("OpenAI Responses route", () => { }), ) + it.effect("lowers the hosted OpenAI image generation tool", () => + Effect.gen(function* () { + const prepared = yield* LLMClient.prepare( + LLM.request({ + model, + prompt: "Show me a rooftop garden.", + tools: [OpenAI.imageGeneration({ action: "generate", quality: "high", size: "1024x1024" })], + toolChoice: "image_generation", + }), + ) + + expect(prepared.body.tools).toEqual([ + { type: "image_generation", action: "generate", quality: "high", size: "1024x1024" }, + ]) + expect(prepared.body.tool_choice).toEqual({ type: "image_generation" }) + }), + ) + + it.effect("rejects invalid hosted image generation options locally", () => + Effect.gen(function* () { + const error = yield* LLMClient.prepare( + LLM.request({ + model, + prompt: "Show me a rooftop garden.", + tools: [OpenAI.imageGeneration({ outputCompression: -1, partialImages: 4, size: "bogus" })], + }), + ).pipe(Effect.flip) + + expect(error.reason._tag).toBe("InvalidRequest") + expect(error.message).toContain("image generation tool options are invalid") + }), + ) + it.effect("lowers semantic service tier options", () => Effect.gen(function* () { const input = LLM.updateRequest(request, { providerOptions: { openai: { serviceTier: "priority" } } }) @@ -1103,6 +1136,48 @@ describe("OpenAI Responses route", () => { }), ) + it.effect("continues stateless hosted image generation with the generated image", () => + Effect.gen(function* () { + const imageTool = OpenAI.imageGeneration({ action: "edit" }) + const prepared = yield* LLMClient.prepare( + LLM.request({ + model, + messages: [ + Message.user("Generate a black triangle."), + Message.assistant([ + ToolCallPart.make({ + id: "ig_1", + name: "image_generation", + input: {}, + providerExecuted: true, + providerMetadata: { openai: { itemId: "ig_1" } }, + }), + ToolResultPart.make({ + id: "ig_1", + name: "image_generation", + result: { + type: "content", + value: [{ type: "file", uri: "data:image/png;base64,AQID", mime: "image/png" }], + }, + providerExecuted: true, + providerMetadata: { openai: { itemId: "ig_1" } }, + }), + ]), + Message.user("Make it blue."), + ], + tools: [imageTool], + }), + ) + + expect(prepared.body.store).toBe(false) + expect(prepared.body.input).toEqual([ + { role: "user", content: [{ type: "input_text", text: "Generate a black triangle." }] }, + { role: "user", content: [{ type: "input_image", image_url: "data:image/png;base64,AQID" }] }, + { role: "user", content: [{ type: "input_text", text: "Make it blue." }] }, + ]) + }), + ) + it.effect("joins streamed summary blocks into one continuation reasoning item", () => Effect.gen(function* () { const prepared = yield* LLMClient.prepare( @@ -1361,6 +1436,59 @@ describe("OpenAI Responses route", () => { }), ) + it.effect("decodes image generation output as image content", () => + Effect.gen(function* () { + const item = { + type: "image_generation_call", + id: "ig_1", + status: "completed", + result: "AQID", + } + const response = yield* LLMClient.generate(request).pipe( + Effect.provide( + fixedResponse( + sseEvents( + { type: "response.output_item.done", item }, + { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } }, + ), + ), + ), + ) + + expect(response.events.find(LLMEvent.is.toolResult)).toMatchObject({ + id: "ig_1", + name: "image_generation", + providerExecuted: true, + result: { + type: "content", + value: [{ type: "file", uri: "data:image/png;base64,AQID", mime: "image/png" }], + }, + }) + }), + ) + + it.effect("rejects malformed image generation base64", () => + Effect.gen(function* () { + const error = yield* LLMClient.generate(request).pipe( + Effect.provide( + fixedResponse( + sseEvents( + { + type: "response.output_item.done", + item: { type: "image_generation_call", id: "ig_bad", status: "completed", result: "%%%" }, + }, + { type: "response.completed", response: {} }, + ), + ), + ), + Effect.flip, + ) + + expect(error.reason._tag).toBe("InvalidProviderOutput") + expect(error.message).toContain("invalid image base64") + }), + ) + it.effect("decodes code_interpreter_call as provider-executed events with code input", () => Effect.gen(function* () { const item = { diff --git a/packages/ai/test/recorded-test.ts b/packages/ai/test/recorded-test.ts index da4008577971..a0df87d9ca28 100644 --- a/packages/ai/test/recorded-test.ts +++ b/packages/ai/test/recorded-test.ts @@ -3,6 +3,8 @@ import { Layer } from "effect" import * as path from "node:path" import { fileURLToPath } from "node:url" import { LLMClient, RequestExecutor, WebSocketExecutor } from "../src/route" +import { ImageClient } from "../src/image-client" +import type { Service as ImageClientService } from "../src/image-client" import type { Service as LLMClientService } from "../src/route/client" import type { Service as RequestExecutorService } from "../src/route/executor" import type { Service as WebSocketExecutorService } from "../src/route/transport/websocket" @@ -15,7 +17,7 @@ import { const __dirname = path.dirname(fileURLToPath(import.meta.url)) const FIXTURES_DIR = path.resolve(__dirname, "fixtures", "recordings") -type RecordedEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService +type RecordedEnv = RequestExecutorService | WebSocketExecutorService | LLMClientService | ImageClientService type RecordedTestsOptions = RecordedGroupOptions & { readonly options?: HttpRecorder.RecorderOptions @@ -81,6 +83,10 @@ export const recordedTests = (options: RecordedTestsOptions) => ), ) const deps = Layer.mergeAll(requestExecutor, WebSocketExecutor.layer) - return Layer.mergeAll(deps, LLMClient.layer.pipe(Layer.provide(deps))) + return Layer.mergeAll( + deps, + LLMClient.layer.pipe(Layer.provide(deps)), + ImageClient.layer.pipe(Layer.provide(deps)), + ) }, })