@runappsai/sdk 0.0.0-stage → 0.3.0

package/src/files.ts

@@ -0,0 +1,347 @@
+// Per-project file system at /v1/files/*.  Files are stored under
+// (user, project) on the gateway and addressed by POSIX-style paths.
+// Each FileObject's `url` is a stable public address — embed it
+// directly in `<img src>`, share it, persist it.
+//
+// The bundle's RunApps client uses `client.files` to access these
+// endpoints; the underlying token must be a project-bound resource
+// token (rrt_*) issued by the grant flow.
+
+import type { Transport } from "./transport.js";
+
+export interface FileObject {
+  path: string;
+  size: number;
+  content_type?: string;
+  etag?: string;
+  last_modified?: string;
+  url: string;
+}
+
+export interface FileListResult {
+  files: FileObject[];
+  next_cursor?: string;
+}
+
+export interface PutOptions {
+  /** Override the MIME type guessed from the path extension. */
+  contentType?: string;
+  /** Refuse to overwrite an existing object (gateway returns 409). */
+  ifNoneMatch?: boolean;
+  /**
+   * Write only if the stored object still has this ETag — the one
+   * `read()` / `stat()` / a previous `put()` returned. Someone else
+   * having written in between makes the gateway answer 412 instead
+   * of silently overwriting their version; re-read, merge, put again.
+   */
+  ifMatch?: string;
+  signal?: AbortSignal;
+}
+
+/** The bytes at a path together with the version they are. */
+export interface FileRead {
+  blob: Blob;
+  contentType: string;
+  /** Pass back as `ifMatch` to write only if nobody else has since. */
+  etag?: string;
+}
+
+export interface ListOptions {
+  prefix?: string;
+  cursor?: string;
+  limit?: number;
+  /**
+   * Shell-style pattern, post-filtered after the underlying S3 list:
+   *   *      any chars except `/`
+   *   **     any chars including `/`
+   *   ?      single non-slash char
+   *   [abc]  character class
+   *
+   * Examples:
+   *   client.files.list({ glob: "*.png" })
+   *   client.files.list({ glob: "projects/*\/assets/*.png" })
+   *   client.files.list({ prefix: "projects/", glob: "**\/*.wav" })
+   *
+   * S3 has no native glob — the gateway extracts the longest literal
+   * head of the pattern as the underlying prefix scan, then filters
+   * the rest in process.  Patterns must match the WHOLE path; no
+   * implicit anchoring needed.
+   */
+  glob?: string;
+  signal?: AbortSignal;
+}
+
+export interface PutFromURLOptions {
+  contentType?: string;
+  ifNoneMatch?: boolean;
+  ifMatch?: string;
+  signal?: AbortSignal;
+}
+
+export type BatchOp =
+  | { op: "put_url"; path: string; src_url: string; content_type?: string; if_none_match?: boolean; if_match?: string }
+  | { op: "del"; path: string }
+  | { op: "move"; from: string; to: string }
+  | { op: "copy"; from: string; to: string }
+  | { op: "exists"; path: string }
+  | { op: "stat"; path: string };
+
+export interface BatchResult {
+  ok: boolean;
+  error?: string;
+  object?: FileObject;
+  exists?: boolean;
+}
+
+function pathToURL(base: string, p: string): string {
+  const trimmed = p.replace(/^\/+/, "");
+  return base + "/" + trimmed.split("/").map(encodeURIComponent).join("/");
+}
+
+export class FilesService {
+  /**
+   * URL prefix for every file call.
+   *
+   * When the client was constructed with `project`, requests go to the
+   * project-scoped form — `/v1/p/<project>/files/...` — instead of the
+   * bare `/v1/files/...`.
+   *
+   * This matters because the unscoped URL is byte-identical across apps:
+   * two bundles built from the same template both read
+   * `projects/index.json`, so anything keying on URL alone (starting
+   * with the browser's HTTP cache, which ignores request headers and is
+   * partitioned by registrable domain, not by subdomain) cannot tell
+   * them apart.  Putting the project in the path makes the URL unique
+   * per app.  The gateway still authorizes purely from the token and
+   * rejects a scope that disagrees with it, so this is a correctness
+   * measure, not a permission one.
+   */
+  private readonly base: string;
+
+  constructor(
+    private readonly transport: Transport,
+    project?: string,
+  ) {
+    this.base = project
+      ? "/v1/p/" + encodeURIComponent(project) + "/files"
+      : "/v1/files";
+  }
+
+  /**
+   * Upload `body` to `path`.  Returns the resulting FileObject — its
+   * `url` is the stable public address for that path.
+   *
+   * `body` accepts anything `fetch` accepts as a request body: Blob,
+   * File, ArrayBuffer, ArrayBufferView, FormData (rare here),
+   * ReadableStream, or a string.
+   */
+  async put(
+    path: string,
+    body: BodyInit,
+    opts?: PutOptions,
+  ): Promise<FileObject> {
+    const headers: Record<string, string> = {};
+    if (opts?.ifNoneMatch) headers["If-None-Match"] = "*";
+    if (opts?.ifMatch) headers["If-Match"] = `"${opts.ifMatch.replace(/"/g, "")}"`;
+    return this.transport.putBytes<FileObject>(pathToURL(this.base, path), body, {
+      contentType: opts?.contentType,
+      headers: Object.keys(headers).length ? headers : undefined,
+      signal: opts?.signal,
+    });
+  }
+
+  /** Convenience: upload string content with sensible content-type. */
+  async putString(
+    path: string,
+    content: string,
+    opts?: PutOptions,
+  ): Promise<FileObject> {
+    return this.put(path, content, {
+      ...opts,
+      contentType: opts?.contentType ?? "text/plain; charset=utf-8",
+    });
+  }
+
+  /**
+   * Download the bytes at `path` as a Blob.  Use `URL.createObjectURL`
+   * to get a temporary local URL, or persist the bytes elsewhere.
+   * Bundles that just need to render an asset should use the FileObject's
+   * `.url` directly instead — that's a stable public URL with no token.
+   */
+  async get(path: string, init?: { signal?: AbortSignal }): Promise<Blob> {
+    return (await this.read(path, init)).blob;
+  }
+
+  /**
+   * Like `get`, but also returns the ETag of the bytes, so a later
+   * `put(path, body, { ifMatch: etag })` writes only if the file is
+   * still the version that was read.
+   */
+  async read(path: string, init?: { signal?: AbortSignal }): Promise<FileRead> {
+    const { data, contentType, etag } = await this.transport.getRaw(pathToURL(this.base, path), init);
+    return {
+      blob: new Blob([new Uint8Array(data)], { type: contentType || "application/octet-stream" }),
+      contentType,
+      etag,
+    };
+  }
+
+  /**
+   * Read a JSON file and its version in one call. A missing file is
+   * `{ value: undefined, etag: undefined }`, so a first save can pass
+   * `ifNoneMatch: true` and a later one `ifMatch: etag`.
+   */
+  async readJSON<T = unknown>(
+    path: string,
+    init?: { signal?: AbortSignal },
+  ): Promise<{ value: T | undefined; etag?: string }> {
+    let r: FileRead;
+    try {
+      r = await this.read(path, init);
+    } catch (e) {
+      if ((e as { statusCode?: number; status?: number })?.statusCode === 404 ||
+          (e as { statusCode?: number; status?: number })?.status === 404) {
+        return { value: undefined, etag: undefined };
+      }
+      throw e;
+    }
+    return { value: JSON.parse(await r.blob.text()) as T, etag: r.etag };
+  }
+
+  /** Stat: HEAD-only object metadata. */
+  async stat(path: string, init?: { signal?: AbortSignal }): Promise<FileObject> {
+    const { status, headers } = await this.transport.head(pathToURL(this.base, path), init);
+    if (status === 404) {
+      throw Object.assign(new Error("not found"), { status: 404 });
+    }
+    if (status >= 400) {
+      throw Object.assign(new Error("stat failed"), { status });
+    }
+    const size = parseInt(headers.get("content-length") ?? "0", 10);
+    return {
+      path: headers.get("x-file-path") ?? path,
+      size,
+      content_type: headers.get("content-type") ?? undefined,
+      etag: (headers.get("etag") ?? "").replace(/"/g, "") || undefined,
+      url: headers.get("x-file-url") ?? "",
+    };
+  }
+
+  /** Returns true iff the path resolves to an existing object. */
+  async exists(path: string, init?: { signal?: AbortSignal }): Promise<boolean> {
+    const { status } = await this.transport.head(pathToURL(this.base, path), init);
+    return status >= 200 && status < 400;
+  }
+
+  /** Delete the object at `path`.  Idempotent. */
+  async del(path: string, init?: { signal?: AbortSignal }): Promise<void> {
+    await this.transport.deletePath<{ ok: boolean }>(pathToURL(this.base, path), init);
+  }
+
+  /** List objects.  Pass an empty / omitted prefix for the root. */
+  async list(opts?: ListOptions): Promise<FileListResult> {
+    const params = new URLSearchParams();
+    if (opts?.prefix) params.set("prefix", opts.prefix);
+    if (opts?.cursor) params.set("cursor", opts.cursor);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    if (opts?.glob) params.set("glob", opts.glob);
+    const qs = params.toString();
+    return this.transport.getJSON<FileListResult>(
+      this.base + (qs ? "?" + qs : ""),
+      opts?.signal ? { signal: opts.signal } : undefined,
+    );
+  }
+
+  /**
+   * Bulk delete: removes every object whose path starts with `prefix`
+   * AND (when set) matches `glob`.  Returns the count of deleted
+   * objects.  Refuses an empty prefix + empty glob — the caller must
+   * be explicit about wiping the project namespace.
+   *
+   *   client.files.deleteMany({ prefix: "tmp/" })          // wipe a directory
+   *   client.files.deleteMany({ glob: "**\/*.tmp" })       // wipe by pattern
+   *   client.files.deleteMany({ prefix: "logs/", glob: "*.bak" })
+   */
+  async deleteMany(
+    opts: { prefix?: string; glob?: string },
+    init?: { signal?: AbortSignal },
+  ): Promise<{ deleted: number }> {
+    return this.transport.postJSON<{ deleted: number }>(
+      this.base + "/delete",
+      { prefix: opts.prefix ?? "", glob: opts.glob ?? "" },
+      init,
+    );
+  }
+
+  /** Atomic rename (copy + delete server-side). */
+  async move(from: string, to: string, init?: { signal?: AbortSignal }): Promise<FileObject> {
+    return this.transport.postJSON<FileObject>(this.base + "/move", { from, to }, init);
+  }
+
+  /** Server-side copy. */
+  async copy(from: string, to: string, init?: { signal?: AbortSignal }): Promise<FileObject> {
+    return this.transport.postJSON<FileObject>(this.base + "/copy", { from, to }, init);
+  }
+
+  /**
+   * Ask the gateway to fetch `srcURL` and store the body at `path`.
+   * Saves a round trip vs downloading then re-uploading.  `srcURL`
+   * must be a public http(s) URL (private/loopback hosts rejected).
+   */
+  async putFromURL(
+    path: string,
+    srcURL: string,
+    opts?: PutFromURLOptions,
+  ): Promise<FileObject> {
+    return this.transport.postJSON<FileObject>(
+      this.base + "/put-url",
+      {
+        path,
+        src_url: srcURL,
+        content_type: opts?.contentType,
+        if_none_match: opts?.ifNoneMatch,
+        if_match: opts?.ifMatch,
+      },
+      opts?.signal ? { signal: opts.signal } : undefined,
+    );
+  }
+
+  /**
+   * Pipeline several file ops in one round trip.  Operations execute
+   * sequentially server-side; one op failing does not abort the rest.
+   * Inspect each result.ok individually.
+   *
+   * Auto-chunks: the gateway caps a single batch at 64 ops and returns
+   * 400 "too many ops" above that.  This method splits long input into
+   * 30-op chunks, awaits each chunk in order, and concatenates the
+   * results — so callers can hand it 1000 ops in a single call.
+   * Chunks run serially (not in parallel) to preserve the
+   * "operations execute in submission order" contract.
+   */
+  async batch(
+    ops: BatchOp[],
+    init?: { signal?: AbortSignal },
+  ): Promise<BatchResult[]> {
+    if (ops.length === 0) return [];
+    const chunkSize = 30;
+    if (ops.length <= chunkSize) {
+      const resp = await this.transport.postJSON<{ results: BatchResult[] }>(
+        this.base + "/batch",
+        { ops },
+        init,
+      );
+      return resp.results;
+    }
+    const all: BatchResult[] = [];
+    for (let i = 0; i < ops.length; i += chunkSize) {
+      const chunk = ops.slice(i, i + chunkSize);
+      const resp = await this.transport.postJSON<{ results: BatchResult[] }>(
+        this.base + "/batch",
+        { ops: chunk },
+        init,
+      );
+      all.push(...resp.results);
+    }
+    return all;
+  }
+}

package/src/image.ts

@@ -0,0 +1,339 @@
+import type { Transport } from "./transport.js";
+import type { Usage } from "./types.js";
+import type { SDKEvents } from "./events.js";
+import { wrapEvents } from "./event-wrap.js";
+
+/**
+ * Image generation request.
+ *
+ * Sizing: prefer the 2-axis `resolution` + `aspect_ratio` controls —
+ * the gateway translates them into a concrete WxH from the target
+ * model's declared size enum. `size` is the legacy explicit override;
+ * when set, it wins over `(resolution, aspect_ratio)`. When none of
+ * the three is set, the gateway / upstream applies its own default.
+ */
+export interface ImageGenerateParams {
+  prompt: string;
+  /** Legacy explicit "WxH" override. Prefer `resolution` +
+   *  `aspect_ratio` for new code. */
+  size?: string;
+  /** Short-side pixel tier — "512P" | "1K" | "2K" | "4K".
+   *  Model-specific subset; `/v1/models` advertises which tiers each
+   *  image model supports. */
+  resolution?: string;
+  /** Output shape — "1:1" | "9:16" | "16:9" | "3:4" | "4:3" | "3:2"
+   *  | "2:3" | "5:4" | "4:5" | "21:9" | "adaptive". Model-specific
+   *  subset; see `/v1/models`. */
+  aspect_ratio?: string;
+  n?: number;
+  style?: string;
+  reference_image_urls?: string[];
+  user?: string;
+  /**
+   * Pass-through for provider-specific knobs.
+   *
+   * Note: `quality` (OpenAI's render-quality preset
+   * — "low"/"medium"/"high"/"auto") was removed from the canonical
+   * surface. Only one upstream used it and its own default ("auto") is
+   * already optimal; the field caused naming confusion with the
+   * "画质" resolution-tier control. The gateway silently drops it
+   * from inbound requests, so legacy callers keep working.
+   */
+  [extra: string]: unknown;
+}
+
+/**
+ * Single generated image. `url` carries the bytes via one of two
+ * transport modes — `<img src={url}>` works for both:
+ *   - "https://api.runapps.ai/v1/blobs/<id>" — async / hosted blob
+ *   - "data:<mime>;base64,<payload>"        — sync / inline
+ *
+ * `decodeMediaUrl(url)` resolves either shape into `Uint8Array` +
+ * mime type when raw bytes are wanted (file save, post-process).
+ *
+ * `size` is the actual dimensions of this image — Seedream sequential
+ * generation may produce results different from the requested size.
+ */
+export interface ImageResult {
+  url: string;
+  revised_prompt?: string;
+  size?: string;
+  /**
+   * Human-readable credit line that the client SHOULD display
+   * alongside the image. Populated by stock-library models (Pexels)
+   * whose terms of service require crediting the photographer;
+   * AI-generation models leave it empty. Render verbatim — don't
+   * try to parse the format.
+   *
+   * Example: "Photo by Jane Doe on Pexels (https://www.pexels.com/photo/12345/)"
+   */
+  attribution?: string;
+}
+
+export interface ImageUsage extends Usage {
+  generated_images?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+  /** Tool name → invocation count (e.g. Seedream 5.0 lite web_search). */
+  tool_usage?: Record<string, number>;
+}
+
+export interface ImageResponse {
+  created: number;
+  data: ImageResult[];
+  usage: ImageUsage;
+}
+
+/**
+ * Status payload returned by the resumable async-image endpoints
+ * (`/v1/async/images/generations` and friends). Returned verbatim by
+ * `submitGenerate()` (job is still queued / running), and again by
+ * `getAsyncStatus()` (status may now be terminal — `data[]` is
+ * populated when `status === 'succeeded'`).
+ *
+ * The fully-managed `generateAsync()` hides this type behind an
+ * `ImageResponse`; `submitGenerate` + `getAsyncStatus` expose it for
+ * callers who need to PERSIST the job id (e.g. resume polling across
+ * a page refresh, drive their own UI progress, etc.).
+ */
+export interface AsyncImageJob {
+  id: string;
+  status: "queued" | "running" | "succeeded" | "failed" | (string & {});
+  data?: ImageResult[];
+  usage?: ImageUsage;
+  error?: string;
+  /** Unix epoch seconds — same semantics as VideoStatus.created_at /
+   *  current_time. Pair to compute server-truth elapsed. */
+  created_at?: number;
+  current_time?: number;
+}
+
+/** Minimal interface for an image / mask file passed to `edit()`. */
+export interface ImageFileInput {
+  /** File contents — Blob, ArrayBuffer, Uint8Array, or string. */
+  data: Blob | ArrayBuffer | Uint8Array | string;
+  /** File name including extension (sent in the multipart field). */
+  filename: string;
+  /** Optional MIME type — inferred from the extension when omitted. */
+  contentType?: string;
+}
+
+export interface ImageEditParams {
+  image: ImageFileInput;
+  mask?: ImageFileInput;
+  prompt: string;
+  size?: string;
+  n?: number;
+  user?: string;
+}
+
+/* ------------------------------------------------------------------ */
+
+export class ImageService {
+  constructor(
+    private readonly transport: Transport,
+    private readonly events: SDKEvents,
+  ) {}
+
+  /**
+   * Generate images from a text prompt via the synchronous endpoint.
+   * For long-running requests (large Seedream batches, slow upstreams)
+   * use `generateAsync()` to avoid 100-second origin timeouts.
+   */
+  async generate(
+    model: string,
+    params: ImageGenerateParams,
+    init?: { signal?: AbortSignal },
+  ): Promise<ImageResponse> {
+    return wrapEvents(
+      this.events,
+      { model, capability: "image_generation" },
+      () =>
+        this.transport.postJSON<ImageResponse>(
+          "/v1/images/generations",
+          { model, ...params },
+          init,
+        ),
+      (r) => ({ costUSD: r.usage?.total_cost }),
+    );
+  }
+
+  /**
+   * Async equivalent of `generate()`. Submits a job to
+   * `/v1/async/images/generations`, polls `/v1/async/images/generations/:id`
+   * until terminal, then resolves to a sync-shape `ImageResponse`. Use
+   * this when a request may exceed the ~100s origin timeout (Cloudflare
+   * otherwise replaces the real upstream error with its own 502 page).
+   *
+   * Implementation is `submitGenerate` + `getAsyncStatus` poll loop, so
+   * the path layout matches the rest of the async API (`/v1/async/...`
+   * everywhere). The caller's `signal` aborts both the submit and the
+   * poll wait; `pollIntervalMs` defaults to 2s.
+   */
+  async generateAsync(
+    model: string,
+    params: ImageGenerateParams,
+    init?: { signal?: AbortSignal; pollIntervalMs?: number },
+  ): Promise<ImageResponse> {
+    const interval = init?.pollIntervalMs ?? 2000;
+    const signal = init?.signal;
+    return wrapEvents(
+      this.events,
+      { model, capability: "image_generation" },
+      async () => {
+        const job = await this.transport.postJSON<AsyncImageJob>(
+          "/v1/async/images/generations",
+          { model, ...params },
+          { signal },
+        );
+        let current = job;
+        while (current.status !== "succeeded" && current.status !== "failed") {
+          await sleep(interval, signal);
+          current = await this.getAsyncStatus(current.id, { signal });
+        }
+        if (current.status === "failed") {
+          throw new Error(current.error ?? "image generation failed");
+        }
+        return {
+          created: current.created_at ?? Math.floor(Date.now() / 1000),
+          data: current.data ?? [],
+          usage: current.usage ?? { total_cost: 0 },
+        } satisfies ImageResponse;
+      },
+      (r) => ({ costUSD: r.usage?.total_cost }),
+    );
+  }
+
+  /**
+   * Submit-only variant of `generate()`. Returns the gateway's job
+   * descriptor (`id`, `status`, `usage`) without polling. Use this
+   * when you want to PERSIST the job id and resume polling later
+   * (e.g. across page reloads, in a separate worker process). Pair
+   * with `getAsyncStatus(id)` to drive the polling loop yourself.
+   *
+   * For a one-shot "submit and wait" call site, use `generateAsync()`
+   * — that wraps the same underlying endpoint with a built-in poll.
+   *
+   * Telemetry note: only the SUBMIT step fires start/end on
+   * `client.events` — the per-call latency reflects the gateway
+   * accepting the job, NOT how long the upstream takes to render.
+   * Track render progress via your own poll loop's status responses.
+   */
+  async submitGenerate(
+    model: string,
+    params: ImageGenerateParams,
+    init?: { signal?: AbortSignal },
+  ): Promise<AsyncImageJob> {
+    return wrapEvents(
+      this.events,
+      { model, capability: "image_generation" },
+      () =>
+        this.transport.postJSON<AsyncImageJob>(
+          "/v1/async/images/generations",
+          { model, ...params },
+          init,
+        ),
+    );
+  }
+
+  /**
+   * Single poll of an in-flight async image job. Returns the same
+   * shape `submitGenerate()` returned, with `data[]` populated once
+   * `status` flips to `succeeded`. Caller decides cadence + bail-out;
+   * the gateway's per-poll `current_time` / `created_at` together
+   * give a server-truth elapsed reading regardless of client clock skew.
+   */
+  async getAsyncStatus(
+    id: string,
+    init?: { signal?: AbortSignal },
+  ): Promise<AsyncImageJob> {
+    return this.transport.getJSON<AsyncImageJob>(
+      `/v1/async/images/generations/${encodeURIComponent(id)}`,
+      init,
+    );
+  }
+
+  /**
+   * Edit an image (inpaint / outpaint / variations) via multipart upload.
+   * Provider-dependent — only available on `gpt-image-1` and similar.
+   */
+  async edit(
+    model: string,
+    params: ImageEditParams,
+    init?: { signal?: AbortSignal },
+  ): Promise<ImageResponse> {
+    const form = buildEditForm(model, params);
+    return wrapEvents(
+      this.events,
+      { model, capability: "image_edit" },
+      () =>
+        this.transport.postMultipart<ImageResponse>(
+          "/v1/images/edits",
+          form,
+          init,
+        ),
+      (r) => ({ costUSD: r.usage?.total_cost }),
+    );
+  }
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal!.reason ?? new Error("aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function buildEditForm(model: string, params: ImageEditParams): FormData {
+  const form = new FormData();
+  form.set("model", model);
+  form.set("prompt", params.prompt);
+  if (params.size) form.set("size", params.size);
+  if (params.n !== undefined) form.set("n", String(params.n));
+  if (params.user) form.set("user", params.user);
+  form.set("image", toBlob(params.image), params.image.filename);
+  if (params.mask) form.set("mask", toBlob(params.mask), params.mask.filename);
+  return form;
+}
+
+/** Internal: coerce ImageFileInput to a Blob the multipart layer accepts. */
+function toBlob(input: ImageFileInput): Blob {
+  const ct = input.contentType ?? guessMime(input.filename);
+  if (input.data instanceof Blob) {
+    return input.data.type === ct ? input.data : new Blob([input.data], { type: ct });
+  }
+  if (typeof input.data === "string") {
+    return new Blob([input.data], { type: ct });
+  }
+  // ArrayBuffer | Uint8Array — wrap in Blob. Cast widens TS's strict
+  // Uint8Array<ArrayBuffer> back to BlobPart (it's accepted at runtime).
+  return new Blob([input.data as BlobPart], { type: ct });
+}
+
+function guessMime(filename: string): string {
+  const ext = filename.toLowerCase().split(".").pop() ?? "";
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    case "gif":
+      return "image/gif";
+    default:
+      return "application/octet-stream";
+  }
+}