@indiciaosint/sdk 1.1.0 → 1.2.0

package/src/lib/event-streams.ts

@@ -0,0 +1,191 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+// Some environments' type definitions do not include ReadableStream's async
+// iterator, even though the runtime supports it or this class polyfills it.
+// Declare the method here so Stream can override it and preserve T in for-await.
+declare global {
+  interface ReadableStream<R = any> {
+    [Symbol.asyncIterator](): {
+      next(): Promise<IteratorResult<R, undefined>>;
+      throw?(e?: unknown): Promise<IteratorResult<R, undefined>>;
+      return?(): Promise<IteratorResult<R, undefined>>;
+      [Symbol.asyncIterator](): any;
+    };
+  }
+}
+
+export type SseMessage<T> = {
+  data?: T | undefined;
+  event?: string | null | undefined;
+  id?: string | null | undefined;
+  retry?: number | null | undefined;
+};
+export class EventStream<T extends SseMessage<unknown>>
+  extends ReadableStream<T>
+{
+  constructor(
+    responseBody: ReadableStream<Uint8Array>,
+    parse: (x: SseMessage<string>) => IteratorResult<T, undefined>,
+    opts?: { dataRequired?: boolean },
+  ) {
+    const upstream = responseBody.getReader();
+    let buffer: Uint8Array = new Uint8Array(4096);
+    let bufferLen = 0;
+    let searchStart = 0;
+    const state = { eventId: undefined as string | undefined };
+    const dataRequired = opts?.dataRequired ?? true;
+    super({
+      async pull(downstream) {
+        try {
+          while (true) {
+            const match = findBoundary(buffer, bufferLen, searchStart);
+            if (!match) {
+              // Bytes before the trailing MAX_BOUNDARY_LEN-1 were already
+              // scanned with full lookahead and cannot start a boundary even
+              // once more data arrives, so the next scan can skip them.
+              searchStart = Math.max(0, bufferLen - MAX_BOUNDARY_LEN + 1);
+              const chunk = await upstream.read();
+              if (chunk.done) return downstream.close();
+              if (bufferLen + chunk.value.length > buffer.length) {
+                const grown = new Uint8Array(
+                  Math.max(buffer.length * 2, bufferLen + chunk.value.length),
+                );
+                grown.set(buffer.subarray(0, bufferLen));
+                buffer = grown;
+              }
+              buffer.set(chunk.value, bufferLen);
+              bufferLen += chunk.value.length;
+              continue;
+            }
+            const message = buffer.slice(0, match.index);
+            buffer.copyWithin(0, match.index + match.length, bufferLen);
+            bufferLen -= match.index + match.length;
+            if (buffer.length > 4096 && bufferLen <= buffer.length >> 2) {
+              // Release oversized capacity retained after an unusually large
+              // event so long-lived streams do not hold peak memory.
+              const shrunk = new Uint8Array(Math.max(4096, bufferLen * 2));
+              shrunk.set(buffer.subarray(0, bufferLen));
+              buffer = shrunk;
+            }
+            searchStart = 0;
+            const item = parseMessage(message, parse, state, dataRequired);
+            if (item && !item.done) return downstream.enqueue(item.value);
+            if (item?.done) {
+              await upstream.cancel("done");
+              return downstream.close();
+            }
+          }
+        } catch (e) {
+          downstream.error(e);
+          await upstream.cancel(e);
+        }
+      },
+      cancel: reason => upstream.cancel(reason),
+    });
+  }
+
+  // Use ReadableStream's iterator return type instead of `any` so stream events
+  // keep their generated type in for-await loops.
+  override [Symbol.asyncIterator](): ReturnType<
+    ReadableStream<T>[typeof Symbol.asyncIterator]
+  > {
+    const fn = (ReadableStream.prototype as any)[Symbol.asyncIterator];
+    if (typeof fn === "function") return fn.call(this);
+    const reader = this.getReader();
+    return {
+      next: async () => {
+        const r = await reader.read();
+        if (r.done) {
+          reader.releaseLock();
+          return { done: true, value: undefined };
+        }
+        return { done: false, value: r.value };
+      },
+      throw: async (e) => {
+        await reader.cancel(e);
+        reader.releaseLock();
+        return { done: true, value: undefined };
+      },
+      return: async () => {
+        await reader.cancel("done");
+        reader.releaseLock();
+        return { done: true, value: undefined };
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    } as ReturnType<ReadableStream<T>[typeof Symbol.asyncIterator]>;
+  }
+}
+
+const CR = 13;
+const LF = 10;
+const BOUNDARIES = [
+  [CR, LF, CR, LF], // \r\n\r\n
+  [CR, LF, CR], // \r\n\r
+  [CR, LF, LF], // \r\n\n
+  [CR, CR, LF], // \r\r\n
+  [LF, CR, LF], // \n\r\n
+  [CR, CR], // \r\r
+  [LF, CR], // \n\r
+  [LF, LF], // \n\n
+];
+const MAX_BOUNDARY_LEN = BOUNDARIES.reduce((m, b) => Math.max(m, b.length), 0);
+
+function findBoundary(
+  buf: Uint8Array,
+  len: number,
+  from: number,
+): { index: number; length: number } | null {
+  for (let i = from; i < len; i++) {
+    if (buf[i] !== CR && buf[i] !== LF) continue;
+    for (const boundary of BOUNDARIES) {
+      if (i + boundary.length > len) continue;
+      let match = true;
+      for (let j = 0; j < boundary.length; j++) {
+        if (buf[i + j] !== boundary[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) return { index: i, length: boundary.length };
+    }
+  }
+  return null;
+}
+function parseMessage<T extends SseMessage<unknown>>(
+  chunk: Uint8Array,
+  parse: (x: SseMessage<string>) => IteratorResult<T, undefined>,
+  state: { eventId: string | undefined },
+  dataRequired: boolean,
+) {
+  const text = new TextDecoder().decode(chunk);
+  const lines = text.split(/\r\n|\r|\n/);
+  const dataLines: string[] = [];
+  const ret: SseMessage<string> = {};
+  let ignore = true;
+  for (const line of lines) {
+    if (!line || line.startsWith(":")) continue;
+    ignore = false;
+    const i = line.indexOf(":");
+    let field = line;
+    let value = "";
+    if (i > 0) {
+      field = line.slice(0, i);
+      value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+    }
+    if (field === "data") dataLines.push(value);
+    else if (field === "event") ret.event = value;
+    else if (field === "id" && !value.includes("\0")) state.eventId = value;
+    else if (field === "retry" && /^\d+$/.test(value)) {
+      ret.retry = Number(value);
+    }
+  }
+  if (ignore) return;
+  ret.id = state.eventId;
+  if (dataLines.length) ret.data = dataLines.join("\n");
+  else if (dataRequired) return; // skip data-less events when data is required
+  return parse(ret);
+}

package/src/lib/security.ts

@@ -247,7 +247,7 @@ export function resolveGlobalSecurity(
       {
         fieldName: "x-api-key",
         type: "apiKey:header",
-        value: security?.apiKeyAuth ?? env().INDICIA_API_KEY_AUTH,
+        value: security?.apiKey ?? env().INDICIA_API_KEY,
       },
     ],
   ];

package/src/models/operations/geolocate-media.ts

@@ -3,8 +3,14 @@
  */
 
 import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
 import { blobLikeSchema } from "../../types/blobs.js";
+import * as discriminatedUnionTypes from "../../types/discriminated-union.js";
+import { discriminatedUnion } from "../../types/discriminated-union.js";
 import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type GeolocateMediaMedia = {
   fileName: string;
@@ -38,6 +44,90 @@ export type GeolocateMediaRequest = {
   model?: Model | undefined;
 };
 
+/**
+ * Terminal event indicating the analysis failed.
+ */
+export type GeolocateMediaErrorEvent = {
+  status: "error";
+  success: false;
+  /**
+   * Human-readable error message.
+   */
+  error: string;
+};
+
+/**
+ * Geolocation analysis result.
+ */
+export type GeolocateMediaData = {
+  /**
+   * Human-readable location name, or null if undetermined.
+   */
+  location: string | null;
+  /**
+   * Comma-separated "latitude,longitude" pair, or null if undetermined.
+   */
+  coordinates: string | null;
+  /**
+   * Confidence level of the geolocation result.
+   */
+  certainty: string;
+  /**
+   * Explanation of how the location was determined.
+   */
+  reasoning: string;
+  /**
+   * Google Maps URL for the determined coordinates.
+   */
+  mapsUrl?: string | undefined;
+};
+
+/**
+ * Terminal event containing the geolocation result.
+ */
+export type GeolocateMediaCompleteEvent = {
+  status: "complete";
+  success: true;
+  /**
+   * Geolocation analysis result.
+   */
+  data: GeolocateMediaData;
+};
+
+/**
+ * Progress heartbeat emitted while analysis is in progress. Sent immediately on connection and then roughly every 10 seconds to keep the connection alive.
+ */
+export type AnalyzingEvent = {
+  status: "analyzing";
+  /**
+   * Unix epoch milliseconds of the heartbeat.
+   */
+  timestamp?: number | undefined;
+};
+
+/**
+ * JSON `data` payload of a geolocation Server-Sent Event. Discriminated by `status`.
+ */
+export type GeolocationEventData =
+  | AnalyzingEvent
+  | GeolocateMediaCompleteEvent
+  | GeolocateMediaErrorEvent
+  | discriminatedUnionTypes.Unknown<"status">;
+
+/**
+ * A Server-Sent Event whose `data` field carries the event payload.
+ */
+export type GeolocationEvent = {
+  /**
+   * JSON `data` payload of a geolocation Server-Sent Event. Discriminated by `status`.
+   */
+  data:
+    | AnalyzingEvent
+    | GeolocateMediaCompleteEvent
+    | GeolocateMediaErrorEvent
+    | discriminatedUnionTypes.Unknown<"status">;
+};
+
 /** @internal */
 export type GeolocateMediaMedia$Outbound = {
   fileName: string;
@@ -96,3 +186,144 @@ export function geolocateMediaRequestToJSON(
     GeolocateMediaRequest$outboundSchema.parse(geolocateMediaRequest),
   );
 }
+
+/** @internal */
+export const GeolocateMediaErrorEvent$inboundSchema: z.ZodMiniType<
+  GeolocateMediaErrorEvent,
+  unknown
+> = z.object({
+  status: types.literal("error"),
+  success: types.literal(false),
+  error: types.string(),
+});
+
+export function geolocateMediaErrorEventFromJSON(
+  jsonString: string,
+): SafeParseResult<GeolocateMediaErrorEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GeolocateMediaErrorEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GeolocateMediaErrorEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const GeolocateMediaData$inboundSchema: z.ZodMiniType<
+  GeolocateMediaData,
+  unknown
+> = z.object({
+  location: types.nullable(types.string()),
+  coordinates: types.nullable(types.string()),
+  certainty: types.string(),
+  reasoning: types.string(),
+  mapsUrl: types.optional(types.string()),
+});
+
+export function geolocateMediaDataFromJSON(
+  jsonString: string,
+): SafeParseResult<GeolocateMediaData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GeolocateMediaData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GeolocateMediaData' from JSON`,
+  );
+}
+
+/** @internal */
+export const GeolocateMediaCompleteEvent$inboundSchema: z.ZodMiniType<
+  GeolocateMediaCompleteEvent,
+  unknown
+> = z.object({
+  status: types.literal("complete"),
+  success: types.literal(true),
+  data: z.lazy(() => GeolocateMediaData$inboundSchema),
+});
+
+export function geolocateMediaCompleteEventFromJSON(
+  jsonString: string,
+): SafeParseResult<GeolocateMediaCompleteEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GeolocateMediaCompleteEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GeolocateMediaCompleteEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const AnalyzingEvent$inboundSchema: z.ZodMiniType<
+  AnalyzingEvent,
+  unknown
+> = z.object({
+  status: types.literal("analyzing"),
+  timestamp: types.optional(types.number()),
+});
+
+export function analyzingEventFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalyzingEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalyzingEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalyzingEvent' from JSON`,
+  );
+}
+
+/** @internal */
+export const GeolocationEventData$inboundSchema: z.ZodMiniType<
+  GeolocationEventData,
+  unknown
+> = discriminatedUnion("status", {
+  analyzing: z.lazy(() => AnalyzingEvent$inboundSchema),
+  complete: z.lazy(() => GeolocateMediaCompleteEvent$inboundSchema),
+  error: z.lazy(() => GeolocateMediaErrorEvent$inboundSchema),
+});
+
+export function geolocationEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<GeolocationEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GeolocationEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GeolocationEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const GeolocationEvent$inboundSchema: z.ZodMiniType<
+  GeolocationEvent,
+  unknown
+> = z.object({
+  data: z.pipe(
+    z.pipe(
+      z.unknown(),
+      z.transform((v, ctx) => {
+        if (typeof v !== "string") return v;
+        try {
+          return JSON.parse(v);
+        } catch (err) {
+          ctx.issues.push({
+            input: v,
+            code: "custom",
+            message: `malformed json: ${err}`,
+          });
+          return z.NEVER;
+        }
+      }),
+    ),
+    discriminatedUnion("status", {
+      analyzing: z.lazy(() => AnalyzingEvent$inboundSchema),
+      complete: z.lazy(() => GeolocateMediaCompleteEvent$inboundSchema),
+      error: z.lazy(() => GeolocateMediaErrorEvent$inboundSchema),
+    }),
+  ),
+});
+
+export function geolocationEventFromJSON(
+  jsonString: string,
+): SafeParseResult<GeolocationEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GeolocationEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GeolocationEvent' from JSON`,
+  );
+}