@roboflow/inference-sdk 0.1.0

package/README.md

@@ -0,0 +1,244 @@
+# @roboflow/inference-sdk
+
+Lightweight client package for Roboflow inference via WebRTC streaming and hosted API.
+
+This package provides WebRTC streaming capabilities and hosted inference API access without bundling TensorFlow or local inference models, making it ideal for production applications.
+
+## Installation
+
+```bash
+npm install @roboflow/inference-sdk
+```
+
+## Quick Start
+
+### Basic WebRTC Streaming Example
+
+```typescript
+import { useStream } from '@roboflow/inference-sdk/webrtc';
+import { connectors } from '@roboflow/inference-sdk/api';
+import { useCamera } from '@roboflow/inference-sdk/streams';
+
+// Create connector (use proxy for production!)
+const connector = connectors.withApiKey("your-api-key");
+
+// Get camera stream
+const stream = await useCamera({
+  video: {
+    facingMode: { ideal: "environment" }
+  }
+});
+
+// Start WebRTC connection
+const connection = await useStream({
+  source: stream,
+  connector,
+  wrtcParams: {
+    workflowSpec: {
+      // Your workflow specification
+      version: "1.0",
+      inputs: [{ type: "InferenceImage", name: "image" }],
+      steps: [/* ... */],
+      outputs: [/* ... */]
+    },
+    imageInputName: "image",
+    streamOutputNames: ["output"],
+    dataOutputNames: ["predictions"]
+  },
+  onData: (data) => {
+    // Receive real-time inference results
+    console.log("Inference results:", data);
+  }
+});
+
+// Display processed video
+const remoteStream = await connection.remoteStream();
+videoElement.srcObject = remoteStream;
+
+// Clean up when done
+await connection.cleanup();
+```
+
+## Security Best Practices
+
+### ⚠️ API Key Security
+
+**NEVER expose your API key in frontend code for production applications.**
+
+The `connectors.withApiKey()` method is convenient for demos and testing, but it exposes your API key in the browser. For production applications, always use a backend proxy:
+
+### Using a Backend Proxy (Recommended)
+
+**Frontend:**
+```typescript
+import { useStream } from '@roboflow/inference-sdk/webrtc';
+import { connectors } from '@roboflow/inference-sdk/api';
+
+// Use proxy endpoint instead of direct API key
+const connector = connectors.withProxyUrl('/api/init-webrtc');
+
+const connection = await useStream({
+  source: stream,
+  connector,
+  wrtcParams: {
+    workflowSpec: { /* ... */ },
+    imageInputName: "image",
+    streamOutputNames: ["output"]
+  }
+});
+```
+
+**Backend (Express example):**
+```typescript
+import { InferenceHTTPClient } from '@roboflow/inference-sdk/api';
+
+app.post('/api/init-webrtc', async (req, res) => {
+  const { offer, wrtcParams } = req.body;
+
+  // API key stays secure on the server
+  const client = InferenceHTTPClient.init({
+    apiKey: process.env.ROBOFLOW_API_KEY
+  });
+
+  const answer = await client.initializeWebrtcWorker({
+    offer,
+    workflowSpec: wrtcParams.workflowSpec,
+    workspaceName: wrtcParams.workspaceName,
+    workflowId: wrtcParams.workflowId,
+    config: {
+      imageInputName: wrtcParams.imageInputName,
+      streamOutputNames: wrtcParams.streamOutputNames,
+      dataOutputNames: wrtcParams.dataOutputNames,
+      threadPoolWorkers: wrtcParams.threadPoolWorkers
+    }
+  });
+
+  res.json(answer);
+});
+```
+
+## API Reference
+
+### WebRTC Functions
+
+#### `useStream(params)`
+
+Establishes a WebRTC connection for real-time video inference.
+
+**Parameters:**
+- `source: MediaStream` - Input video stream (from camera or other source)
+- `connector: Connector` - Connection method (withApiKey or withProxyUrl)
+- `wrtcParams: WebRTCParams` - Workflow configuration
+  - `workflowSpec?: WorkflowSpec` - Workflow specification object
+  - `workspaceName?: string` - Workspace name (alternative to workflowSpec)
+  - `workflowId?: string` - Workflow ID (alternative to workflowSpec)
+  - `imageInputName?: string` - Input image name (default: "image")
+  - `streamOutputNames?: string[]` - Output stream names
+  - `dataOutputNames?: string[]` - Output data names
+  - `threadPoolWorkers?: number` - Thread pool workers (default: 4)
+- `onData?: (data: any) => void` - Callback for data output
+- `options?: UseStreamOptions` - Additional options
+
+**Returns:** `Promise<RFWebRTCConnection>`
+
+### Connection Methods
+
+#### `connection.remoteStream()`
+
+Get the processed video stream from Roboflow.
+
+**Returns:** `Promise<MediaStream>`
+
+#### `connection.localStream()`
+
+Get the local input video stream.
+
+**Returns:** `MediaStream`
+
+#### `connection.cleanup()`
+
+Close the connection and clean up resources.
+
+**Returns:** `Promise<void>`
+
+#### `connection.reconfigureOutputs(config)`
+
+Dynamically change stream and data outputs at runtime without restarting the connection.
+
+**Parameters:**
+- `config.streamOutput?: string[] | null` - Stream output names
+  - `undefined` or not provided: Unchanged
+  - `[]`: Auto-detect first valid image output
+  - `["output_name"]`: Use specified output
+  - `null`: Unchanged
+- `config.dataOutput?: string[] | null` - Data output names
+  - `undefined` or not provided: Unchanged
+  - `[]`: Disable all data outputs
+  - `["output_name"]`: Use specified outputs
+  - `null`: Enable all data outputs
+
+**Examples:**
+```typescript
+// Change to different stream output
+connection.reconfigureOutputs({
+  streamOutput: ["annotated_image"]
+});
+
+// Enable all data outputs
+connection.reconfigureOutputs({
+  dataOutput: null
+});
+
+// Disable all data outputs
+connection.reconfigureOutputs({
+  dataOutput: []
+});
+
+// Change both at once
+connection.reconfigureOutputs({
+  streamOutput: ["visualization"],
+  dataOutput: ["predictions", "metadata"]
+});
+```
+
+### Camera Functions
+
+#### `useCamera(constraints)`
+
+Access device camera with specified constraints.
+
+**Parameters:**
+- `constraints: MediaStreamConstraints` - Media constraints
+
+**Returns:** `Promise<MediaStream>`
+
+#### `stopStream(stream)`
+
+Stop a media stream and release camera.
+
+**Parameters:**
+- `stream: MediaStream` - Stream to stop
+
+## When to Use This Package
+
+### Use `@roboflow/inference-sdk` when:
+- Building production web applications
+- You need WebRTC streaming inference
+- You want a smaller bundle size
+- You're deploying to browsers
+
+### Use the full `inferencejs` package when:
+- You need local inference with TensorFlow.js
+- You want to run models offline in the browser
+- You need both local and hosted inference options
+
+## Resources
+
+- [Roboflow Documentation](https://docs.roboflow.com/)
+- [API Authentication Guide](https://docs.roboflow.com/api-reference/authentication)
+- [Workflows Documentation](https://docs.roboflow.com/workflows)
+- [GitHub Repository](https://github.com/roboflow/inferencejs)
+
+## License
+
+See the main repository for license information.

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Roboflow Inference Client
+ *
+ * Lightweight client library for Roboflow's hosted inference API.
+ * Provides WebRTC streaming, HTTP client, and camera utilities.
+ */
+export * from './inference-api';
+import * as webrtc from './webrtc';
+import * as streams from './streams';
+export { webrtc, streams };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,iBAAiB,CAAC;AAGhC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC"}

package/dist/index.es.js

@@ -0,0 +1,455 @@
+var C = Object.defineProperty;
+var E = (r, e, t) => e in r ? C(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var l = (r, e, t) => E(r, typeof e != "symbol" ? e + "" : e, t);
+class y {
+  /**
+   * @private
+   * Use InferenceHTTPClient.init() instead
+   */
+  constructor(e, t = "https://serverless.roboflow.com") {
+    l(this, "apiKey");
+    l(this, "serverUrl");
+    this.apiKey = e, this.serverUrl = t;
+  }
+  static init({ apiKey: e, serverUrl: t }) {
+    if (!e)
+      throw new Error("apiKey is required");
+    return new y(e, t);
+  }
+  /**
+   * Initialize a WebRTC worker pipeline
+   *
+   * @param params - Pipeline parameters
+   * @param params.offer - WebRTC offer { sdp, type }
+   * @param params.workflowSpec - Workflow specification
+   * @param params.config - Additional configuration
+   * @param params.config.imageInputName - Input image name (default: "image")
+   * @param params.config.streamOutputNames - Output stream names for video (default: [])
+   * @param params.config.dataOutputNames - Output data names (default: ["string"])
+   * @param params.config.threadPoolWorkers - Thread pool workers (default: 4)
+   * @returns Promise resolving to answer with SDP and pipeline ID
+   *
+   * @example
+   * ```typescript
+   * const answer = await client.initializeWebrtcWorker({
+   *   offer: { sdp, type },
+   *   workflowSpec: { ... },
+   *   config: {
+   *     imageInputName: "image",
+   *     streamOutputNames: ["output_image"]
+   *   }
+   * });
+   * ```
+   */
+  async initializeWebrtcWorker({
+    offer: e,
+    workflowSpec: t,
+    workspaceName: a,
+    workflowId: n,
+    config: i = {}
+  }) {
+    if (!e || !e.sdp || !e.type)
+      throw new Error("offer with sdp and type is required");
+    const o = !!t, s = !!(a && n);
+    if (!o && !s)
+      throw new Error("Either workflowSpec OR (workspaceName + workflowId) is required");
+    if (o && s)
+      throw new Error("Provide either workflowSpec OR (workspaceName + workflowId), not both");
+    const {
+      imageInputName: d = "image",
+      streamOutputNames: u = [],
+      dataOutputNames: p = ["string"],
+      threadPoolWorkers: c = 4
+    } = i, h = {
+      type: "WorkflowConfiguration",
+      image_input_name: d,
+      workflows_thread_pool_workers: c,
+      cancel_thread_pool_tasks_on_exit: !0,
+      video_metadata_input_name: "video_metadata"
+    };
+    o ? h.workflow_specification = t : (h.workspace_name = a, h.workflow_id = n);
+    const g = {
+      workflow_configuration: h,
+      api_key: this.apiKey,
+      webrtc_realtime_processing: !0,
+      webrtc_offer: {
+        sdp: e.sdp,
+        type: e.type
+      },
+      webrtc_turn_config: null,
+      stream_output: u,
+      data_output: p
+    }, m = await fetch(`${this.serverUrl}/initialise_webrtc_worker`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(g)
+    });
+    if (!m.ok) {
+      const f = await m.text().catch(() => "");
+      throw new Error(`initialise_webrtc_worker failed (${m.status}): ${f}`);
+    }
+    return await m.json();
+  }
+  async terminatePipeline({ pipelineId: e }) {
+    if (!e)
+      throw new Error("pipelineId is required");
+    await fetch(
+      `${this.serverUrl}/inference_pipelines/${e}/terminate?api_key=${this.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+const N = {
+  /**
+   * Create a connector that uses API key directly
+   *
+   * **WARNING**: If you use this in the frontend, it will expose your API key. 
+   * Use only for demos/testing.
+   * For production, use withProxyUrl() with a backend proxy.
+   *
+   * @param apiKey - Roboflow API key
+   * @param options - Additional options
+   * @param options.serverUrl - Custom Roboflow server URL
+   * @returns Connector with connectWrtc method
+   *
+   * @example
+   * ```typescript
+   * const connector = connectors.withApiKey("your-api-key");
+   * const answer = await connector.connectWrtc(offer, wrtcParams);
+   * ```
+   */
+  withApiKey(r, e = {}) {
+    const { serverUrl: t } = e;
+    return typeof window < "u" && console.warn(
+      "[Security Warning] Using API key directly in browser will expose it. Use connectors.withProxyUrl() for production. See: https://docs.roboflow.com/api-reference/authentication#securing-your-api-key"
+    ), {
+      connectWrtc: async (a, n) => await y.init({ apiKey: r, serverUrl: t }).initializeWebrtcWorker({
+        offer: a,
+        workflowSpec: n.workflowSpec,
+        workspaceName: n.workspaceName,
+        workflowId: n.workflowId,
+        config: {
+          imageInputName: n.imageInputName,
+          streamOutputNames: n.streamOutputNames,
+          dataOutputNames: n.dataOutputNames,
+          threadPoolWorkers: n.threadPoolWorkers
+        }
+      }),
+      // Store apiKey for cleanup
+      _apiKey: r,
+      _serverUrl: t
+    };
+  },
+  /**
+   * Create a connector that uses a backend proxy (recommended for production)
+   *
+   * Your backend receives the offer and wrtcParams, adds the secret API key,
+   * and forwards to Roboflow. This keeps your API key secure.
+   *
+   * @param proxyUrl - Backend proxy endpoint URL
+   * @param options - Additional options (reserved for future use)
+   * @returns Connector with connectWrtc method
+   *
+   * @example
+   * ```typescript
+   * const connector = connectors.withProxyUrl('/api/init-webrtc');
+   * const answer = await connector.connectWrtc(offer, wrtcParams);
+   * ```
+   *
+   * @example
+   * Backend implementation (Express):
+   * ```typescript
+   * app.post('/api/init-webrtc', async (req, res) => {
+   *   const { offer, wrtcParams } = req.body;
+   *   const client = InferenceHTTPClient.init({
+   *     apiKey: process.env.ROBOFLOW_API_KEY
+   *   });
+   *   const answer = await client.initializeWebrtcWorker({
+   *     offer,
+   *     workflowSpec: wrtcParams.workflowSpec,
+   *     workspaceName: wrtcParams.workspaceName,
+   *     workflowId: wrtcParams.workflowId,
+   *     config: {
+   *       imageInputName: wrtcParams.imageInputName,
+   *       streamOutputNames: wrtcParams.streamOutputNames,
+   *       dataOutputNames: wrtcParams.dataOutputNames,
+   *       threadPoolWorkers: wrtcParams.threadPoolWorkers
+   *     }
+   *   });
+   *   res.json(answer);
+   * });
+   * ```
+   */
+  withProxyUrl(r, e = {}) {
+    return {
+      connectWrtc: async (t, a) => {
+        const n = await fetch(r, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            offer: t,
+            wrtcParams: a
+          })
+        });
+        if (!n.ok) {
+          const i = await n.text().catch(() => "");
+          throw new Error(`Proxy request failed (${n.status}): ${i}`);
+        }
+        return await n.json();
+      }
+    };
+  }
+};
+async function R(r = { video: !0 }) {
+  try {
+    console.log("[RFStreams] requesting with", r);
+    const e = await navigator.mediaDevices.getUserMedia(r);
+    return console.log("[RFStreams] got stream", e.getVideoTracks().map((t) => ({ id: t.id, label: t.label }))), e;
+  } catch (e) {
+    console.warn("[RFStreams] failed, falling back", e);
+    const t = await navigator.mediaDevices.getUserMedia({ video: !0, audio: !1 });
+    return console.log("[RFStreams] fallback stream", t.getVideoTracks().map((a) => ({ id: a.id, label: a.label }))), t;
+  }
+}
+function _(r) {
+  r && (r.getTracks().forEach((e) => e.stop()), console.log("[RFStreams] Stream stopped"));
+}
+const x = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  stopStream: _,
+  useCamera: R
+}, Symbol.toStringTag, { value: "Module" }));
+async function T(r, e = 6e3) {
+  if (r.iceGatheringState === "complete") return;
+  let t = !1;
+  const a = (n) => {
+    n.candidate && n.candidate.type === "srflx" && (t = !0);
+  };
+  r.addEventListener("icecandidate", a);
+  try {
+    await Promise.race([
+      new Promise((n) => {
+        const i = () => {
+          r.iceGatheringState === "complete" && (r.removeEventListener("icegatheringstatechange", i), n());
+        };
+        r.addEventListener("icegatheringstatechange", i);
+      }),
+      new Promise((n, i) => {
+        setTimeout(() => {
+          t ? n() : (console.error("[ICE] timeout with NO srflx candidate! Connection may fail."), i(new Error("ICE gathering timeout without srflx candidate")));
+        }, e);
+      })
+    ]);
+  } finally {
+    r.removeEventListener("icecandidate", a);
+  }
+}
+function W(r) {
+  return new Promise((e) => {
+    r.addEventListener("track", (t) => {
+      t.streams && t.streams[0] && e(t.streams[0]);
+    });
+  });
+}
+async function O(r) {
+  const e = "stun:stun.l.google.com:19302", t = new RTCPeerConnection({
+    iceServers: [{ urls: [e] }]
+  });
+  try {
+    t.addTransceiver("video", { direction: "recvonly" });
+  } catch (o) {
+    console.warn("[RFWebRTC] Could not add transceiver:", o);
+  }
+  r.getVideoTracks().forEach((o) => {
+    try {
+      o.contentHint = "detail";
+    } catch {
+    }
+    t.addTrack(o, r);
+  });
+  const a = W(t), n = t.createDataChannel("roboflow-control", {
+    ordered: !0
+  }), i = await t.createOffer();
+  return await t.setLocalDescription(i), await T(t), {
+    pc: t,
+    offer: t.localDescription,
+    remoteStreamPromise: a,
+    dataChannel: n
+  };
+}
+async function P(r) {
+  const e = r.getSenders().find((a) => a.track && a.track.kind === "video");
+  if (!e) return;
+  const t = e.getParameters();
+  t.encodings = t.encodings || [{}], t.encodings[0].scaleResolutionDownBy = 1;
+  try {
+    await e.setParameters(t);
+  } catch (a) {
+    console.warn("[RFWebRTC] Failed to set encoding parameters:", a);
+  }
+}
+class k {
+  /** @private */
+  constructor(e, t, a, n, i, o, s) {
+    l(this, "pc");
+    l(this, "_localStream");
+    l(this, "remoteStreamPromise");
+    l(this, "pipelineId");
+    l(this, "apiKey");
+    l(this, "dataChannel");
+    this.pc = e, this._localStream = t, this.remoteStreamPromise = a, this.pipelineId = n, this.apiKey = i, this.dataChannel = o, s && (this.dataChannel.addEventListener("open", () => {
+    }), this.dataChannel.addEventListener("message", (d) => {
+      try {
+        const u = JSON.parse(d.data);
+        s(u);
+      } catch (u) {
+        console.error("[RFWebRTC] Failed to parse data channel message:", u), s(d.data);
+      }
+    }), this.dataChannel.addEventListener("error", (d) => {
+      console.error("[RFWebRTC] Data channel error:", d);
+    }), this.dataChannel.addEventListener("close", () => {
+    }));
+  }
+  /**
+   * Get the remote stream (processed video from Roboflow)
+   *
+   * @returns Promise resolving to the remote MediaStream
+   *
+   * @example
+   * ```typescript
+   * const conn = await useStream({ ... });
+   * const remoteStream = await conn.remoteStream();
+   * videoElement.srcObject = remoteStream;
+   * ```
+   */
+  async remoteStream() {
+    return await this.remoteStreamPromise;
+  }
+  /**
+   * Get the local stream (original camera)
+   *
+   * @returns The local MediaStream
+   *
+   * @example
+   * ```typescript
+   * const conn = await useStream({ ... });
+   * const localStream = conn.localStream();
+   * videoElement.srcObject = localStream;
+   * ```
+   */
+  localStream() {
+    return this._localStream;
+  }
+  /**
+   * Cleanup and close connection
+   *
+   * Terminates the pipeline on Roboflow, closes the peer connection,
+   * and stops the local media stream.
+   *
+   * @returns Promise that resolves when cleanup is complete
+   *
+   * @example
+   * ```typescript
+   * const conn = await useStream({ ... });
+   * // ... use connection ...
+   * await conn.cleanup(); // Clean up when done
+   * ```
+   */
+  async cleanup() {
+    this.pipelineId && this.apiKey && await y.init({ apiKey: this.apiKey }).terminatePipeline({ pipelineId: this.pipelineId }), this.pc && this.pc.connectionState !== "closed" && this.pc.close(), _(this._localStream);
+  }
+  /**
+   * Reconfigure pipeline outputs at runtime
+   *
+   * Dynamically change stream and data outputs without restarting the connection.
+   * Set a field to `null` to leave it unchanged, or to `null` value to enable all outputs,
+   * or to `[]` to disable/auto-detect.
+   *
+   * @param config - Output configuration
+   * @param config.streamOutput - Stream output names (null = unchanged, [] = auto-detect, ["name"] = specific output)
+   * @param config.dataOutput - Data output names (null = unchanged, [] = disable, ["name"] = specific outputs, null value = all outputs)
+   *
+   * @example
+   * ```typescript
+   * // Change to different stream output
+   * connection.reconfigureOutputs({
+   *   streamOutput: ["annotated_image"],
+   *   dataOutput: null  // unchanged
+   * });
+   *
+   * // Enable all data outputs
+   * connection.reconfigureOutputs({
+   *   streamOutput: null,  // unchanged
+   *   dataOutput: null     // null value = all outputs
+   * });
+   *
+   * // Disable all data outputs
+   * connection.reconfigureOutputs({
+   *   streamOutput: null,  // unchanged
+   *   dataOutput: []       // empty array = disable
+   * });
+   * ```
+   */
+  reconfigureOutputs(e) {
+    const t = {};
+    e.streamOutput !== void 0 && (t.stream_output = e.streamOutput), e.dataOutput !== void 0 && (t.data_output = e.dataOutput), this.sendData(t);
+  }
+  /**
+   * Send data through the data channel
+   * @private
+   */
+  sendData(e) {
+    if (this.dataChannel.readyState !== "open") {
+      console.warn("[RFWebRTC] Data channel is not open. Current state:", this.dataChannel.readyState);
+      return;
+    }
+    try {
+      const t = typeof e == "string" ? e : JSON.stringify(e);
+      this.dataChannel.send(t);
+    } catch (t) {
+      console.error("[RFWebRTC] Failed to send data:", t);
+    }
+  }
+}
+async function I({
+  source: r,
+  connector: e,
+  wrtcParams: t,
+  onData: a,
+  options: n = {}
+}) {
+  var f;
+  if (!e || typeof e.connectWrtc != "function")
+    throw new Error("connector must have a connectWrtc method");
+  const i = r, { pc: o, offer: s, remoteStreamPromise: d, dataChannel: u } = await O(i), p = await e.connectWrtc(
+    { sdp: s.sdp, type: s.type },
+    t
+  ), c = { sdp: p.sdp, type: p.type };
+  if (!(c != null && c.sdp) || !(c != null && c.type))
+    throw console.error("[RFWebRTC] Invalid answer from server:", p), new Error("connector.connectWrtc must return answer with sdp and type");
+  const h = ((f = p == null ? void 0 : p.context) == null ? void 0 : f.pipeline_id) || null;
+  await o.setRemoteDescription(c), await new Promise((b, S) => {
+    const w = () => {
+      o.connectionState === "connected" ? (o.removeEventListener("connectionstatechange", w), b()) : o.connectionState === "failed" && (o.removeEventListener("connectionstatechange", w), S(new Error("WebRTC connection failed")));
+    };
+    o.addEventListener("connectionstatechange", w), w(), setTimeout(() => {
+      o.removeEventListener("connectionstatechange", w), S(new Error("WebRTC connection timeout after 30s"));
+    }, 3e4);
+  }), n.disableInputStreamDownscaling !== !1 && await P(o);
+  const m = e._apiKey || null;
+  return new k(o, i, d, h, m, u, a);
+}
+const D = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RFWebRTCConnection: k,
+  useStream: I
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  y as InferenceHTTPClient,
+  N as connectors,
+  x as streams,
+  D as webrtc
+};

package/dist/index.js

@@ -0,0 +1 @@
+(function(c,i){typeof exports=="object"&&typeof module<"u"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(c=typeof globalThis<"u"?globalThis:c||self,i(c.RoboflowClient={}))})(this,function(c){"use strict";var D=Object.defineProperty;var L=(c,i,f)=>i in c?D(c,i,{enumerable:!0,configurable:!0,writable:!0,value:f}):c[i]=f;var p=(c,i,f)=>L(c,typeof i!="symbol"?i+"":i,f);class i{constructor(t,e="https://serverless.roboflow.com"){p(this,"apiKey");p(this,"serverUrl");this.apiKey=t,this.serverUrl=e}static init({apiKey:t,serverUrl:e}){if(!t)throw new Error("apiKey is required");return new i(t,e)}async initializeWebrtcWorker({offer:t,workflowSpec:e,workspaceName:a,workflowId:n,config:s={}}){if(!t||!t.sdp||!t.type)throw new Error("offer with sdp and type is required");const o=!!e,l=!!(a&&n);if(!o&&!l)throw new Error("Either workflowSpec OR (workspaceName + workflowId) is required");if(o&&l)throw new Error("Provide either workflowSpec OR (workspaceName + workflowId), not both");const{imageInputName:u="image",streamOutputNames:m=[],dataOutputNames:h=["string"],threadPoolWorkers:d=4}=s,w={type:"WorkflowConfiguration",image_input_name:u,workflows_thread_pool_workers:d,cancel_thread_pool_tasks_on_exit:!0,video_metadata_input_name:"video_metadata"};o?w.workflow_specification=e:(w.workspace_name=a,w.workflow_id=n);const k={workflow_configuration:w,api_key:this.apiKey,webrtc_realtime_processing:!0,webrtc_offer:{sdp:t.sdp,type:t.type},webrtc_turn_config:null,stream_output:m,data_output:h},y=await fetch(`${this.serverUrl}/initialise_webrtc_worker`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(k)});if(!y.ok){const S=await y.text().catch(()=>"");throw new Error(`initialise_webrtc_worker failed (${y.status}): ${S}`)}return await y.json()}async terminatePipeline({pipelineId:t}){if(!t)throw new Error("pipelineId is required");await fetch(`${this.serverUrl}/inference_pipelines/${t}/terminate?api_key=${this.apiKey}`,{method:"POST",headers:{"Content-Type":"application/json"}})}}const f={withApiKey(r,t={}){const{serverUrl:e}=t;return typeof window<"u"&&console.warn("[Security Warning] Using API key directly in browser will expose it. Use connectors.withProxyUrl() for production. See: https://docs.roboflow.com/api-reference/authentication#securing-your-api-key"),{connectWrtc:async(a,n)=>await i.init({apiKey:r,serverUrl:e}).initializeWebrtcWorker({offer:a,workflowSpec:n.workflowSpec,workspaceName:n.workspaceName,workflowId:n.workflowId,config:{imageInputName:n.imageInputName,streamOutputNames:n.streamOutputNames,dataOutputNames:n.dataOutputNames,threadPoolWorkers:n.threadPoolWorkers}}),_apiKey:r,_serverUrl:e}},withProxyUrl(r,t={}){return{connectWrtc:async(e,a)=>{const n=await fetch(r,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({offer:e,wrtcParams:a})});if(!n.ok){const s=await n.text().catch(()=>"");throw new Error(`Proxy request failed (${n.status}): ${s}`)}return await n.json()}}}};async function C(r={video:!0}){try{console.log("[RFStreams] requesting with",r);const t=await navigator.mediaDevices.getUserMedia(r);return console.log("[RFStreams] got stream",t.getVideoTracks().map(e=>({id:e.id,label:e.label}))),t}catch(t){console.warn("[RFStreams] failed, falling back",t);const e=await navigator.mediaDevices.getUserMedia({video:!0,audio:!1});return console.log("[RFStreams] fallback stream",e.getVideoTracks().map(a=>({id:a.id,label:a.label}))),e}}function _(r){r&&(r.getTracks().forEach(t=>t.stop()),console.log("[RFStreams] Stream stopped"))}const T=Object.freeze(Object.defineProperty({__proto__:null,stopStream:_,useCamera:C},Symbol.toStringTag,{value:"Module"}));async function R(r,t=6e3){if(r.iceGatheringState==="complete")return;let e=!1;const a=n=>{n.candidate&&n.candidate.type==="srflx"&&(e=!0)};r.addEventListener("icecandidate",a);try{await Promise.race([new Promise(n=>{const s=()=>{r.iceGatheringState==="complete"&&(r.removeEventListener("icegatheringstatechange",s),n())};r.addEventListener("icegatheringstatechange",s)}),new Promise((n,s)=>{setTimeout(()=>{e?n():(console.error("[ICE] timeout with NO srflx candidate! Connection may fail."),s(new Error("ICE gathering timeout without srflx candidate")))},t)})])}finally{r.removeEventListener("icecandidate",a)}}function E(r){return new Promise(t=>{r.addEventListener("track",e=>{e.streams&&e.streams[0]&&t(e.streams[0])})})}async function O(r){const t="stun:stun.l.google.com:19302",e=new RTCPeerConnection({iceServers:[{urls:[t]}]});try{e.addTransceiver("video",{direction:"recvonly"})}catch(o){console.warn("[RFWebRTC] Could not add transceiver:",o)}r.getVideoTracks().forEach(o=>{try{o.contentHint="detail"}catch{}e.addTrack(o,r)});const a=E(e),n=e.createDataChannel("roboflow-control",{ordered:!0}),s=await e.createOffer();return await e.setLocalDescription(s),await R(e),{pc:e,offer:e.localDescription,remoteStreamPromise:a,dataChannel:n}}async function W(r){const t=r.getSenders().find(a=>a.track&&a.track.kind==="video");if(!t)return;const e=t.getParameters();e.encodings=e.encodings||[{}],e.encodings[0].scaleResolutionDownBy=1;try{await t.setParameters(e)}catch(a){console.warn("[RFWebRTC] Failed to set encoding parameters:",a)}}class b{constructor(t,e,a,n,s,o,l){p(this,"pc");p(this,"_localStream");p(this,"remoteStreamPromise");p(this,"pipelineId");p(this,"apiKey");p(this,"dataChannel");this.pc=t,this._localStream=e,this.remoteStreamPromise=a,this.pipelineId=n,this.apiKey=s,this.dataChannel=o,l&&(this.dataChannel.addEventListener("open",()=>{}),this.dataChannel.addEventListener("message",u=>{try{const m=JSON.parse(u.data);l(m)}catch(m){console.error("[RFWebRTC] Failed to parse data channel message:",m),l(u.data)}}),this.dataChannel.addEventListener("error",u=>{console.error("[RFWebRTC] Data channel error:",u)}),this.dataChannel.addEventListener("close",()=>{}))}async remoteStream(){return await this.remoteStreamPromise}localStream(){return this._localStream}async cleanup(){this.pipelineId&&this.apiKey&&await i.init({apiKey:this.apiKey}).terminatePipeline({pipelineId:this.pipelineId}),this.pc&&this.pc.connectionState!=="closed"&&this.pc.close(),_(this._localStream)}reconfigureOutputs(t){const e={};t.streamOutput!==void 0&&(e.stream_output=t.streamOutput),t.dataOutput!==void 0&&(e.data_output=t.dataOutput),this.sendData(e)}sendData(t){if(this.dataChannel.readyState!=="open"){console.warn("[RFWebRTC] Data channel is not open. Current state:",this.dataChannel.readyState);return}try{const e=typeof t=="string"?t:JSON.stringify(t);this.dataChannel.send(e)}catch(e){console.error("[RFWebRTC] Failed to send data:",e)}}}async function P({source:r,connector:t,wrtcParams:e,onData:a,options:n={}}){var S;if(!t||typeof t.connectWrtc!="function")throw new Error("connector must have a connectWrtc method");const s=r,{pc:o,offer:l,remoteStreamPromise:u,dataChannel:m}=await O(s),h=await t.connectWrtc({sdp:l.sdp,type:l.type},e),d={sdp:h.sdp,type:h.type};if(!(d!=null&&d.sdp)||!(d!=null&&d.type))throw console.error("[RFWebRTC] Invalid answer from server:",h),new Error("connector.connectWrtc must return answer with sdp and type");const w=((S=h==null?void 0:h.context)==null?void 0:S.pipeline_id)||null;await o.setRemoteDescription(d),await new Promise((N,v)=>{const g=()=>{o.connectionState==="connected"?(o.removeEventListener("connectionstatechange",g),N()):o.connectionState==="failed"&&(o.removeEventListener("connectionstatechange",g),v(new Error("WebRTC connection failed")))};o.addEventListener("connectionstatechange",g),g(),setTimeout(()=>{o.removeEventListener("connectionstatechange",g),v(new Error("WebRTC connection timeout after 30s"))},3e4)}),n.disableInputStreamDownscaling!==!1&&await W(o);const y=t._apiKey||null;return new b(o,s,u,w,y,m,a)}const I=Object.freeze(Object.defineProperty({__proto__:null,RFWebRTCConnection:b,useStream:P},Symbol.toStringTag,{value:"Module"}));c.InferenceHTTPClient=i,c.connectors=f,c.streams=T,c.webrtc=I,Object.defineProperty(c,Symbol.toStringTag,{value:"Module"})});

package/dist/inference-api.d.ts

@@ -0,0 +1,150 @@
+export interface WebRTCWorkerConfig {
+    imageInputName?: string;
+    streamOutputNames?: string[];
+    dataOutputNames?: string[];
+    threadPoolWorkers?: number;
+}
+export interface WebRTCOffer {
+    sdp: string;
+    type: string;
+}
+export type WorkflowSpec = Record<string, any>;
+export interface WebRTCWorkerResponse {
+    status?: string;
+    sdp: string;
+    type: string;
+    context?: {
+        request_id: string | null;
+        pipeline_id: string | null;
+    };
+}
+export interface WebRTCParams {
+    workflowSpec?: WorkflowSpec;
+    workspaceName?: string;
+    workflowId?: string;
+    imageInputName?: string;
+    streamOutputNames?: string[];
+    dataOutputNames?: string[];
+    threadPoolWorkers?: number;
+}
+export interface Connector {
+    connectWrtc(offer: WebRTCOffer, wrtcParams: WebRTCParams): Promise<WebRTCWorkerResponse>;
+    _apiKey?: string;
+    _serverUrl?: string;
+}
+export declare class InferenceHTTPClient {
+    private apiKey;
+    private serverUrl;
+    /**
+     * @private
+     * Use InferenceHTTPClient.init() instead
+     */
+    private constructor();
+    static init({ apiKey, serverUrl }: {
+        apiKey: string;
+        serverUrl?: string;
+    }): InferenceHTTPClient;
+    /**
+     * Initialize a WebRTC worker pipeline
+     *
+     * @param params - Pipeline parameters
+     * @param params.offer - WebRTC offer { sdp, type }
+     * @param params.workflowSpec - Workflow specification
+     * @param params.config - Additional configuration
+     * @param params.config.imageInputName - Input image name (default: "image")
+     * @param params.config.streamOutputNames - Output stream names for video (default: [])
+     * @param params.config.dataOutputNames - Output data names (default: ["string"])
+     * @param params.config.threadPoolWorkers - Thread pool workers (default: 4)
+     * @returns Promise resolving to answer with SDP and pipeline ID
+     *
+     * @example
+     * ```typescript
+     * const answer = await client.initializeWebrtcWorker({
+     *   offer: { sdp, type },
+     *   workflowSpec: { ... },
+     *   config: {
+     *     imageInputName: "image",
+     *     streamOutputNames: ["output_image"]
+     *   }
+     * });
+     * ```
+     */
+    initializeWebrtcWorker({ offer, workflowSpec, workspaceName, workflowId, config }: {
+        offer: WebRTCOffer;
+        workflowSpec?: WorkflowSpec;
+        workspaceName?: string;
+        workflowId?: string;
+        config?: WebRTCWorkerConfig;
+    }): Promise<WebRTCWorkerResponse>;
+    terminatePipeline({ pipelineId }: {
+        pipelineId: string;
+    }): Promise<void>;
+}
+/**
+ * Connectors for establishing WebRTC connections to Roboflow
+ */
+export declare const connectors: {
+    /**
+     * Create a connector that uses API key directly
+     *
+     * **WARNING**: If you use this in the frontend, it will expose your API key.
+     * Use only for demos/testing.
+     * For production, use withProxyUrl() with a backend proxy.
+     *
+     * @param apiKey - Roboflow API key
+     * @param options - Additional options
+     * @param options.serverUrl - Custom Roboflow server URL
+     * @returns Connector with connectWrtc method
+     *
+     * @example
+     * ```typescript
+     * const connector = connectors.withApiKey("your-api-key");
+     * const answer = await connector.connectWrtc(offer, wrtcParams);
+     * ```
+     */
+    withApiKey(apiKey: string, options?: {
+        serverUrl?: string;
+    }): Connector;
+    /**
+     * Create a connector that uses a backend proxy (recommended for production)
+     *
+     * Your backend receives the offer and wrtcParams, adds the secret API key,
+     * and forwards to Roboflow. This keeps your API key secure.
+     *
+     * @param proxyUrl - Backend proxy endpoint URL
+     * @param options - Additional options (reserved for future use)
+     * @returns Connector with connectWrtc method
+     *
+     * @example
+     * ```typescript
+     * const connector = connectors.withProxyUrl('/api/init-webrtc');
+     * const answer = await connector.connectWrtc(offer, wrtcParams);
+     * ```
+     *
+     * @example
+     * Backend implementation (Express):
+     * ```typescript
+     * app.post('/api/init-webrtc', async (req, res) => {
+     *   const { offer, wrtcParams } = req.body;
+     *   const client = InferenceHTTPClient.init({
+     *     apiKey: process.env.ROBOFLOW_API_KEY
+     *   });
+     *   const answer = await client.initializeWebrtcWorker({
+     *     offer,
+     *     workflowSpec: wrtcParams.workflowSpec,
+     *     workspaceName: wrtcParams.workspaceName,
+     *     workflowId: wrtcParams.workflowId,
+     *     config: {
+     *       imageInputName: wrtcParams.imageInputName,
+     *       streamOutputNames: wrtcParams.streamOutputNames,
+     *       dataOutputNames: wrtcParams.dataOutputNames,
+     *       threadPoolWorkers: wrtcParams.threadPoolWorkers
+     *     }
+     *   });
+     *   res.json(answer);
+     * });
+     * ```
+     */
+    withProxyUrl(proxyUrl: string, options?: Record<string, any>): Connector;
+};
+//# sourceMappingURL=inference-api.d.ts.map

package/dist/inference-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference-api.d.ts","sourceRoot":"","sources":["../src/inference-api.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAE/C,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE;QACR,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,CAAC;CACH;AAED,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,SAAS;IACxB,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACzF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACH,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,mBAAmB;IAO/F;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,sBAAsB,CAAC,EAC3B,KAAK,EACL,YAAY,EACZ,aAAa,EACb,UAAU,EACV,MAAW,EACZ,EAAE;QACD,KAAK,EAAE,WAAW,CAAC;QACnB,YAAY,CAAC,EAAE,YAAY,CAAC;QAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,kBAAkB,CAAC;KAC7B,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAoE3B,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAa/E;AAED;;GAEG;AACH,eAAO,MAAM,UAAU;IACrB;;;;;;;;;;;;;;;;;OAiBG;uBACgB,MAAM,YAAW;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAQ,SAAS;IAsC3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;2BACoB,MAAM,YAAW,OAAO,MAAM,EAAE,GAAG,CAAC,GAAQ,SAAS;CAqB7E,CAAC"}

package/dist/streams.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get a camera stream with the given constraints.
+ *
+ * @param constraints - MediaStreamConstraints for getUserMedia
+ * @returns Promise that resolves to MediaStream
+ *
+ * @example
+ * ```typescript
+ * const stream = await useCamera({
+ *   video: {
+ *     facingMode: { ideal: "user" },
+ *     width: { ideal: 1280 },
+ *     height: { ideal: 720 },
+ *     frameRate: { ideal: 30 }
+ *   },
+ *   audio: false
+ * });
+ * ```
+ */
+export declare function useCamera(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+export declare function stopStream(stream: MediaStream | null | undefined): void;
+//# sourceMappingURL=streams.d.ts.map

package/dist/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../src/streams.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,SAAS,CAAC,WAAW,GAAE,sBAAwC,GAAG,OAAO,CAAC,WAAW,CAAC,CAY3G;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAKvE"}

package/dist/webrtc.d.ts

@@ -0,0 +1,147 @@
+import { Connector, WebRTCParams } from "./inference-api";
+export interface UseStreamOptions {
+    disableInputStreamDownscaling?: boolean;
+}
+export interface UseStreamParams {
+    source: MediaStream;
+    connector: Connector;
+    wrtcParams: WebRTCParams;
+    onData?: (data: any) => void;
+    options?: UseStreamOptions;
+}
+/**
+ * WebRTC Connection object
+ *
+ * Represents an active WebRTC connection to Roboflow for streaming inference.
+ */
+export declare class RFWebRTCConnection {
+    private pc;
+    private _localStream;
+    private remoteStreamPromise;
+    private pipelineId;
+    private apiKey;
+    private dataChannel;
+    /** @private */
+    constructor(pc: RTCPeerConnection, localStream: MediaStream, remoteStreamPromise: Promise<MediaStream>, pipelineId: string | null, apiKey: string | null, dataChannel: RTCDataChannel, onData?: (data: any) => void);
+    /**
+     * Get the remote stream (processed video from Roboflow)
+     *
+     * @returns Promise resolving to the remote MediaStream
+     *
+     * @example
+     * ```typescript
+     * const conn = await useStream({ ... });
+     * const remoteStream = await conn.remoteStream();
+     * videoElement.srcObject = remoteStream;
+     * ```
+     */
+    remoteStream(): Promise<MediaStream>;
+    /**
+     * Get the local stream (original camera)
+     *
+     * @returns The local MediaStream
+     *
+     * @example
+     * ```typescript
+     * const conn = await useStream({ ... });
+     * const localStream = conn.localStream();
+     * videoElement.srcObject = localStream;
+     * ```
+     */
+    localStream(): MediaStream;
+    /**
+     * Cleanup and close connection
+     *
+     * Terminates the pipeline on Roboflow, closes the peer connection,
+     * and stops the local media stream.
+     *
+     * @returns Promise that resolves when cleanup is complete
+     *
+     * @example
+     * ```typescript
+     * const conn = await useStream({ ... });
+     * // ... use connection ...
+     * await conn.cleanup(); // Clean up when done
+     * ```
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Reconfigure pipeline outputs at runtime
+     *
+     * Dynamically change stream and data outputs without restarting the connection.
+     * Set a field to `null` to leave it unchanged, or to `null` value to enable all outputs,
+     * or to `[]` to disable/auto-detect.
+     *
+     * @param config - Output configuration
+     * @param config.streamOutput - Stream output names (null = unchanged, [] = auto-detect, ["name"] = specific output)
+     * @param config.dataOutput - Data output names (null = unchanged, [] = disable, ["name"] = specific outputs, null value = all outputs)
+     *
+     * @example
+     * ```typescript
+     * // Change to different stream output
+     * connection.reconfigureOutputs({
+     *   streamOutput: ["annotated_image"],
+     *   dataOutput: null  // unchanged
+     * });
+     *
+     * // Enable all data outputs
+     * connection.reconfigureOutputs({
+     *   streamOutput: null,  // unchanged
+     *   dataOutput: null     // null value = all outputs
+     * });
+     *
+     * // Disable all data outputs
+     * connection.reconfigureOutputs({
+     *   streamOutput: null,  // unchanged
+     *   dataOutput: []       // empty array = disable
+     * });
+     * ```
+     */
+    reconfigureOutputs(config: {
+        streamOutput?: string[] | null;
+        dataOutput?: string[] | null;
+    }): void;
+    /**
+     * Send data through the data channel
+     * @private
+     */
+    private sendData;
+}
+/**
+ * Main function to establish WebRTC streaming connection
+ *
+ * Creates a WebRTC connection to Roboflow for real-time inference on video streams.
+ *
+ * @param params - Connection parameters
+ * @returns Promise resolving to RFWebRTCConnection
+ *
+ * @example
+ * ```typescript
+ * import { useStream } from 'inferencejs/webrtc';
+ * import { connectors } from 'inferencejs/api';
+ * import { useCamera } from 'inferencejs/streams';
+ *
+ * const connector = connectors.withApiKey("your-api-key");
+ * const stream = await useCamera({ video: { facingMode: { ideal: "environment" } } });
+ * const conn = await useStream({
+ *   source: stream,
+ *   connector,
+ *   wrtcParams: {
+ *     workflowSpec: {
+ *       // Your workflow specification
+ *     },
+ *     imageInputName: "image",
+ *     streamOutputNames: ["output"],
+ *     dataOutputNames: ["predictions"]
+ *   },
+ *   onData: (data) => {
+ *     console.log("Inference results:", data);
+ *   }
+ * });
+ *
+ * const remoteStream = await conn.remoteStream();
+ * videoElement.srcObject = remoteStream;
+ * ```
+ */
+export declare function useStream({ source, connector, wrtcParams, onData, options }: UseStreamParams): Promise<RFWebRTCConnection>;
+//# sourceMappingURL=webrtc.d.ts.map

package/dist/webrtc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webrtc.d.ts","sourceRoot":"","sources":["../src/webrtc.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,SAAS,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAG/E,MAAM,WAAW,gBAAgB;IAC/B,6BAA6B,CAAC,EAAE,OAAO,CAAC;CACzC;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,YAAY,CAAC;IACzB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,CAAC;IAC7B,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AA4HD;;;;GAIG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,WAAW,CAAiB;IAEpC,eAAe;gBAEb,EAAE,EAAE,iBAAiB,EACrB,WAAW,EAAE,WAAW,EACxB,mBAAmB,EAAE,OAAO,CAAC,WAAW,CAAC,EACzC,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,WAAW,EAAE,cAAc,EAC3B,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI;IAmC9B;;;;;;;;;;;OAWG;IACG,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC;IAI1C;;;;;;;;;;;OAWG;IACH,WAAW,IAAI,WAAW;IAI1B;;;;;;;;;;;;;;OAcG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAAkB,CAAC,MAAM,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI;IAclG;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAajB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,SAAS,CAAC,EAC9B,MAAM,EACN,SAAS,EACT,UAAU,EACV,MAAM,EACN,OAAY,EACb,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkE/C"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@roboflow/inference-sdk",
+  "version": "0.1.0",
+  "description": "Lightweight client for Roboflow's hosted inference API with WebRTC streaming support",
+  "keywords": [
+    "roboflow",
+    "computer-vision",
+    "webrtc",
+    "inference",
+    "object-detection"
+  ],
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "clean": "rm -rf dist"
+  },
+  "author": "Roboflow",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/roboflow/inference-sdk.git"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "vite": "^5.3.3",
+    "vite-plugin-dts": "^3.7.2"
+  },
+  "dependencies": {}
+}