modjules 0.1.1

package/dist/client-D2GRjxRE.mjs

@@ -0,0 +1,927 @@
+class g extends Error {
+  /** The original error that caused this error, if any. */
+  cause;
+  constructor(t, e) {
+    super(t), this.name = this.constructor.name, this.cause = e?.cause;
+  }
+}
+class k extends g {
+  url;
+  constructor(t, e) {
+    super(`Network request to ${t} failed`, e), this.url = t;
+  }
+}
+class f extends g {
+  url;
+  status;
+  statusText;
+  constructor(t, e, i, a, r) {
+    const o = a ?? `[${e} ${i}] Request to ${t} failed`;
+    super(o, r), this.url = t, this.status = e, this.statusText = i;
+  }
+}
+class x extends f {
+  constructor(t, e, i) {
+    super(
+      t,
+      e,
+      i,
+      `[${e} ${i}] Authentication to ${t} failed. Ensure your API key is correct.`
+    );
+  }
+}
+class E extends f {
+  constructor(t, e, i) {
+    super(
+      t,
+      e,
+      i,
+      `[${e} ${i}] API rate limit exceeded for ${t}.`
+    );
+  }
+}
+class I extends g {
+  constructor() {
+    super(
+      "Jules API key is missing. Pass it to the constructor or set the JULES_API_KEY environment variable."
+    );
+  }
+}
+class A extends g {
+  constructor(t) {
+    super(`Could not get source '${t}'`);
+  }
+}
+class P extends g {
+  constructor(t) {
+    let e = "The Jules automated session terminated with a FAILED state.";
+    t && (e += ` Reason: ${t}`), super(e);
+  }
+}
+class q extends g {
+  constructor(t) {
+    super(t);
+  }
+}
+class U {
+  apiKey;
+  baseUrl;
+  requestTimeoutMs;
+  constructor(t) {
+    this.apiKey = t.apiKey, this.baseUrl = t.baseUrl, this.requestTimeoutMs = t.requestTimeoutMs;
+  }
+  async request(t, e = {}) {
+    if (!this.apiKey)
+      throw new I();
+    const { method: i = "GET", body: a, params: r } = e, o = new URL(`${this.baseUrl}/${t}`);
+    r && Object.entries(r).forEach(([l, u]) => {
+      o.searchParams.append(l, u);
+    });
+    const p = {
+      "X-Goog-Api-Key": this.apiKey,
+      "Content-Type": "application/json"
+    }, c = new AbortController(), d = setTimeout(
+      () => c.abort(),
+      this.requestTimeoutMs
+    );
+    let n;
+    try {
+      n = await fetch(o.toString(), {
+        method: i,
+        headers: p,
+        body: a ? JSON.stringify(a) : void 0,
+        signal: c.signal
+      });
+    } catch (l) {
+      throw new k(o.toString(), {
+        cause: l
+      });
+    } finally {
+      clearTimeout(d);
+    }
+    if (!n.ok)
+      switch (n.status) {
+        case 401:
+        case 403:
+          throw new x(
+            o.toString(),
+            n.status,
+            n.statusText
+          );
+        case 429:
+          throw new E(
+            o.toString(),
+            n.status,
+            n.statusText
+          );
+        default:
+          const l = await n.text().catch(() => "Could not read error body"), u = `[${n.status} ${n.statusText}] ${i} ${o.toString()} - ${l}`;
+          throw new f(
+            o.toString(),
+            n.status,
+            n.statusText,
+            u
+          );
+      }
+    const h = await n.text();
+    return h ? JSON.parse(h) : {};
+  }
+}
+function v(s) {
+  if (s.githubRepo)
+    return {
+      name: s.name,
+      id: s.id,
+      type: "githubRepo",
+      githubRepo: s.githubRepo
+    };
+  throw new Error(`Unknown source type for source: ${s.name}`);
+}
+class R {
+  apiClient;
+  constructor(t) {
+    this.apiClient = t;
+  }
+  /**
+   * Lists all connected sources.
+   *
+   * **Logic:**
+   * - Automatically handles API pagination by following `nextPageToken`.
+   * - Yields sources one by one as they are retrieved.
+   */
+  async *list() {
+    let t;
+    for (; ; ) {
+      const e = { pageSize: "100" };
+      t && (e.pageToken = t);
+      const i = await this.apiClient.request(
+        "sources",
+        { params: e }
+      );
+      if (i && i.sources)
+        for (const a of i.sources)
+          yield v(a);
+      if (t = i?.nextPageToken, !t)
+        break;
+    }
+  }
+  /**
+   * Retrieves a specific source by its external identifier.
+   *
+   * **Data Transformation:**
+   * - Constructs a resource name (e.g., `sources/github/owner/repo`) from the input filter.
+   *
+   * @param filter Filter criteria (currently supports GitHub repo name).
+   * @returns The matching Source object, or `undefined` if not found (404).
+   * @throws {Error} If the filter format is invalid.
+   */
+  async get(t) {
+    const { github: e } = t;
+    if (!e || !e.includes("/"))
+      throw new Error("Invalid GitHub filter. Expected format: 'owner/repo'.");
+    const i = `sources/github/${e}`;
+    try {
+      const a = await this.apiClient.request(i);
+      return a ? v(a) : void 0;
+    } catch (a) {
+      if (a instanceof f && a.status === 404)
+        return;
+      throw a;
+    }
+  }
+}
+function O(s) {
+  const t = new R(s), i = t.list.bind(t);
+  return i.get = t.get.bind(t), i;
+}
+typeof process < "u" && process.versions != null && process.versions.node != null;
+class _ {
+  type = "media";
+  data;
+  format;
+  platform;
+  activityId;
+  constructor(t, e, i) {
+    this.data = t.data, this.format = t.format, this.platform = e, this.activityId = i;
+  }
+  /**
+   * Saves the media artifact to a file.
+   *
+   * **Side Effects:**
+   * - Node.js: Writes the file to disk (overwrites if exists).
+   * - Browser: Saves the file to the 'artifacts' object store in IndexedDB.
+   *
+   * @param filepath The path where the file should be saved.
+   */
+  async save(t) {
+    await this.platform.saveFile(
+      t,
+      this.data,
+      "base64",
+      this.activityId
+    );
+  }
+  /**
+   * Converts the media artifact to a data URL.
+   * Useful for displaying images in a browser.
+   *
+   * **Data Transformation:**
+   * - Prefixes the base64 data with `data:<mimeType>;base64,`.
+   *
+   * @returns A valid Data URI string.
+   */
+  toUrl() {
+    return this.platform.createDataUrl(this.data, this.format);
+  }
+}
+class F {
+  type = "bashOutput";
+  command;
+  stdout;
+  stderr;
+  exitCode;
+  constructor(t) {
+    this.command = t.command, this.stdout = t.stdout, this.stderr = t.stderr, this.exitCode = t.exitCode;
+  }
+  /**
+   * Formats the bash output as a string, mimicking a terminal session.
+   *
+   * **Data Transformation:**
+   * - Combines `stdout` and `stderr`.
+   * - Formats the command with a `$` prompt.
+   * - Appends the exit code.
+   */
+  toString() {
+    const t = [this.stdout, this.stderr].filter(Boolean).join(""), e = `$ ${this.command}`, i = t ? `${t}
+` : "", a = `[exit code: ${this.exitCode ?? "N/A"}]`;
+    return `${e}
+${i}${a}`;
+  }
+}
+function N(s, t, e) {
+  if ("changeSet" in s)
+    return { type: "changeSet", changeSet: s.changeSet };
+  if ("media" in s)
+    return new _(s.media, t, e);
+  if ("bashOutput" in s)
+    return new F(s.bashOutput);
+  throw new Error(`Unknown artifact type: ${JSON.stringify(s)}`);
+}
+function w(s, t) {
+  const {
+    name: e,
+    createTime: i,
+    originator: a,
+    artifacts: r
+  } = s, o = e.split("/").pop(), p = (r || []).map(
+    (d) => N(d, t, o)
+  ), c = {
+    name: e,
+    id: o,
+    createTime: i,
+    originator: a || "system",
+    artifacts: p
+  };
+  if (s.agentMessaged)
+    return {
+      ...c,
+      type: "agentMessaged",
+      message: s.agentMessaged.agentMessage
+    };
+  if (s.userMessaged)
+    return {
+      ...c,
+      type: "userMessaged",
+      message: s.userMessaged.userMessage
+    };
+  if (s.planGenerated)
+    return {
+      ...c,
+      type: "planGenerated",
+      plan: s.planGenerated.plan
+    };
+  if (s.planApproved)
+    return {
+      ...c,
+      type: "planApproved",
+      planId: s.planApproved.planId
+    };
+  if (s.progressUpdated)
+    return {
+      ...c,
+      type: "progressUpdated",
+      title: s.progressUpdated.title,
+      description: s.progressUpdated.description
+    };
+  if (s.sessionCompleted)
+    return {
+      ...c,
+      type: "sessionCompleted"
+    };
+  if (s.sessionFailed)
+    return {
+      ...c,
+      type: "sessionFailed",
+      reason: s.sessionFailed.reason
+    };
+  throw new Error("Unknown activity type");
+}
+function b(s) {
+  if (s.state === "failed")
+    throw new P(`Session ${s.id} failed.`);
+  const t = s.outputs.find((i) => "pullRequest" in i), e = t ? t.pullRequest : void 0;
+  return {
+    sessionId: s.id,
+    title: s.title,
+    state: "completed",
+    // We only call this mapper on a completed session.
+    pullRequest: e,
+    outputs: s.outputs
+  };
+}
+const T = (s) => new Promise((t) => setTimeout(t, s));
+async function* J(s, t, e, i, a = {}) {
+  let r, o = !0;
+  const p = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    let c;
+    try {
+      c = await t.request(
+        `sessions/${s}/activities`,
+        {
+          params: {
+            pageSize: "50",
+            // A reasonable page size
+            ...r ? { pageToken: r } : {}
+          }
+        }
+      );
+    } catch (n) {
+      if (o && n instanceof f && n.status === 404) {
+        let h = n, l, u = 1e3;
+        for (let y = 0; y < 5; y++) {
+          await T(u), u *= 2;
+          try {
+            l = await t.request(
+              `sessions/${s}/activities`,
+              {
+                params: {
+                  pageSize: "50",
+                  ...r ? { pageToken: r } : {}
+                }
+              }
+            );
+            break;
+          } catch (m) {
+            if (m instanceof f && m.status === 404)
+              h = m;
+            else
+              throw m;
+          }
+        }
+        if (l)
+          c = l;
+        else
+          throw h;
+      } else
+        throw n;
+    }
+    o = !1;
+    const d = c.activities || [];
+    for (const n of d) {
+      if (p.has(n.name))
+        continue;
+      const h = w(n, i);
+      a.exclude?.originator && h.originator === a.exclude.originator || (p.add(n.name), yield h);
+    }
+    if (c.nextPageToken) {
+      r = c.nextPageToken;
+      continue;
+    } else
+      r = void 0, await T(e);
+  }
+}
+const D = (s) => new Promise((t) => setTimeout(t, s));
+async function C(s, t, e, i) {
+  for (; ; ) {
+    const a = await t.request(
+      `sessions/${s}`
+    );
+    if (e(a))
+      return a;
+    await D(i);
+  }
+}
+async function M(s, t, e) {
+  return C(
+    s,
+    t,
+    (i) => i.state === "completed" || i.state === "failed",
+    e
+  );
+}
+class K {
+  constructor(t, e) {
+    this.storage = t, this.network = e;
+  }
+  /**
+   * Returns an async iterable of all activities stored locally.
+   */
+  async *history() {
+    await this.storage.init(), yield* this.storage.scan();
+  }
+  /**
+   * Returns an async iterable of new activities from the network.
+   * This method polls the network and updates the local storage.
+   *
+   * **Side Effects:**
+   * - Polls the network continuously.
+   * - Appends new activities to local storage (write-through caching).
+   *
+   * **Logic:**
+   * - Reads the latest activity from storage to determine the "high-water mark".
+   * - Ignores incoming activities older than or equal to the high-water mark.
+   */
+  async *updates() {
+    await this.storage.init();
+    const t = await this.storage.latest();
+    let e = t?.createTime ? new Date(t.createTime).getTime() : 0, i = t?.id;
+    for await (const a of this.network.rawStream()) {
+      const r = new Date(a.createTime).getTime();
+      r < e || r === e && a.id === i || (await this.storage.append(a), e = r, i = a.id, yield a);
+    }
+  }
+  /**
+   * Returns a combined stream of history and updates.
+   * This is the primary method for consuming the activity stream.
+   *
+   * **Behavior:**
+   * 1. Yields all historical activities from local storage (offline capable).
+   * 2. Switches to `updates()` to yield new activities from the network (real-time).
+   */
+  async *stream() {
+    yield* this.history(), yield* this.updates();
+  }
+  /**
+   * Queries local storage for activities matching the given options.
+   */
+  async select(t = {}) {
+    await this.storage.init();
+    const e = [];
+    let i = !t.after, a = 0;
+    for await (const r of this.storage.scan()) {
+      if (!i) {
+        r.id === t.after && (i = !0);
+        continue;
+      }
+      if (t.before && r.id === t.before)
+        break;
+      if (!(t.type && r.type !== t.type) && (e.push(r), a++, t.limit && a >= t.limit))
+        break;
+    }
+    return e;
+  }
+  /**
+   * Lists activities from the network directly.
+   * @param options Pagination options.
+   */
+  async list(t) {
+    return this.network.listActivities(t);
+  }
+  /**
+   * Gets a single activity by ID.
+   * Implements a "read-through" caching strategy.
+   *
+   * **Logic:**
+   * 1. Checks local storage. If found, returns it immediately (fast).
+   * 2. If missing, fetches from the network.
+   * 3. Persists the fetched activity to storage (future reads will hit cache).
+   * 4. Returns the activity.
+   *
+   * **Side Effects:**
+   * - May perform a network request.
+   * - May write to local storage.
+   */
+  async get(t) {
+    await this.storage.init();
+    const e = await this.storage.get(t);
+    if (e)
+      return e;
+    const i = await this.network.fetchActivity(t);
+    return await this.storage.append(i), i;
+  }
+}
+class L {
+  constructor(t, e, i = 5e3, a) {
+    this.apiClient = t, this.sessionId = e, this.pollingIntervalMs = i, this.platform = a;
+  }
+  /**
+   * Fetches a single activity from the API.
+   */
+  async fetchActivity(t) {
+    const e = await this.apiClient.request(
+      `sessions/${this.sessionId}/activities/${t}`
+    );
+    return w(e, this.platform);
+  }
+  /**
+   * Lists activities from the API with pagination.
+   */
+  async listActivities(t) {
+    const e = {};
+    t?.pageSize && (e.pageSize = t.pageSize.toString()), t?.pageToken && (e.pageToken = t.pageToken);
+    const i = await this.apiClient.request(`sessions/${this.sessionId}/activities`, { params: e });
+    return {
+      activities: (i.activities || []).map(
+        (a) => w(a, this.platform)
+      ),
+      nextPageToken: i.nextPageToken
+    };
+  }
+  /**
+   * Polls the API for new activities and yields them.
+   * This stream never ends unless the process is terminated.
+   */
+  async *rawStream() {
+    for (; ; ) {
+      let t;
+      do {
+        const e = await this.listActivities({ pageToken: t });
+        for (const i of e.activities)
+          yield i;
+        t = e.nextPageToken;
+      } while (t);
+      await this.platform.sleep(this.pollingIntervalMs);
+    }
+  }
+}
+class S {
+  id;
+  apiClient;
+  config;
+  // The new client instance
+  _activities;
+  /**
+   * Creates a new instance of SessionClientImpl.
+   *
+   * @param sessionId The ID of the session.
+   * @param apiClient The API client to use for network requests.
+   * @param config The configuration options.
+   * @param storage The storage engine for activities.
+   * @param platform The platform adapter.
+   */
+  constructor(t, e, i, a, r) {
+    this.id = t.replace(/^sessions\//, ""), this.apiClient = e, this.config = i;
+    const o = new L(
+      this.apiClient,
+      this.id,
+      this.config.pollingIntervalMs,
+      r
+    );
+    this._activities = new K(a, o);
+  }
+  /**
+   * COLD STREAM: Yields all known past activities from local storage.
+   */
+  history() {
+    return this._activities.history();
+  }
+  /**
+   * HOT STREAM: Yields ONLY future activities as they arrive from the network.
+   */
+  updates() {
+    return this._activities.updates();
+  }
+  /**
+   * LOCAL QUERY: Performs rich filtering against local storage only.
+   */
+  select(t) {
+    return this._activities.select(t);
+  }
+  /**
+   * Provides a real-time stream of activities for the session.
+   *
+   * @param options Options to control the stream.
+   */
+  async *stream(t = {}) {
+    for await (const e of this._activities.stream())
+      t.exclude?.originator && e.originator === t.exclude.originator || (yield e);
+  }
+  /**
+   * Approves the currently pending plan.
+   * Only valid if the session state is `awaitingPlanApproval`.
+   *
+   * **Side Effects:**
+   * - Sends a POST request to `sessions/{id}:approvePlan`.
+   * - Transitions the session state from `awaitingPlanApproval` to `inProgress` (eventually).
+   *
+   * @throws {InvalidStateError} If the session is not in the `awaitingPlanApproval` state.
+   *
+   * @example
+   * await session.waitFor('awaitingPlanApproval');
+   * await session.approve();
+   */
+  async approve() {
+    const t = (await this.info()).state;
+    if (t !== "awaitingPlanApproval")
+      throw new q(
+        `Cannot approve plan because the session is not awaiting approval. Current state: ${t}`
+      );
+    await this.apiClient.request(`sessions/${this.id}:approvePlan`, {
+      method: "POST",
+      body: {}
+    });
+  }
+  /**
+   * Sends a message (prompt) to the agent in the context of the current session.
+   * This is a fire-and-forget operation. To see the response, use `stream()` or `ask()`.
+   *
+   * **Side Effects:**
+   * - Sends a POST request to `sessions/{id}:sendMessage`.
+   * - Appends a new `userMessaged` activity to the session history.
+   *
+   * @param prompt The message to send.
+   *
+   * @example
+   * await session.send("Please clarify step 2.");
+   */
+  async send(t) {
+    await this.apiClient.request(`sessions/${this.id}:sendMessage`, {
+      method: "POST",
+      body: { prompt: t }
+    });
+  }
+  /**
+   * Sends a message to the agent and waits specifically for the agent's immediate reply.
+   * This provides a convenient request/response flow for conversational interactions.
+   *
+   * **Behavior:**
+   * - Sends the prompt using `send()`.
+   * - Subscribes to the activity stream.
+   * - Resolves with the first `agentMessaged` activity that appears *after* the prompt was sent.
+   *
+   * @param prompt The message to send.
+   * @returns The agent's reply activity.
+   * @throws {JulesError} If the session terminates before the agent replies.
+   *
+   * @example
+   * const reply = await session.ask("What is the status?");
+   * console.log(reply.message);
+   */
+  async ask(t) {
+    const e = /* @__PURE__ */ new Date();
+    await this.send(t);
+    for await (const i of this.stream({
+      exclude: { originator: "user" }
+    })) {
+      const a = new Date(i.createTime).getTime(), r = e.getTime();
+      if (!(a <= r) && i.type === "agentMessaged")
+        return i;
+    }
+    throw new g("Session ended before the agent replied.");
+  }
+  /**
+   * Waits for the session to reach a terminal state and returns the result.
+   *
+   * **Behavior:**
+   * - Polls the session API until state is 'completed' or 'failed'.
+   * - Maps the final session resource to a friendly `Outcome` object.
+   *
+   * @returns The final outcome of the session.
+   * @throws {AutomatedSessionFailedError} If the session ends in a 'failed' state.
+   */
+  async result() {
+    const t = await M(
+      this.id,
+      this.apiClient,
+      this.config.pollingIntervalMs
+    );
+    return b(t);
+  }
+  /**
+   * Pauses execution and waits until the session reaches a specific state.
+   * Also returns if the session reaches a terminal state ('completed' or 'failed')
+   * to prevent infinite waiting.
+   *
+   * **Behavior:**
+   * - Polls the session API at the configured interval.
+   * - Resolves immediately if the session is already in the target state (or terminal).
+   *
+   * @param targetState The target state to wait for.
+   *
+   * @example
+   * await session.waitFor('awaitingPlanApproval');
+   */
+  async waitFor(t) {
+    await C(
+      this.id,
+      this.apiClient,
+      (e) => e.state === t || e.state === "completed" || e.state === "failed",
+      this.config.pollingIntervalMs
+    );
+  }
+  /**
+   * Retrieves the latest state of the underlying session resource from the API.
+   */
+  async info() {
+    return this.apiClient.request(`sessions/${this.id}`);
+  }
+}
+async function z(s, t, e = {}) {
+  const i = e.concurrency ?? 3, a = e.stopOnError ?? !0, r = e.delayMs ?? 0, o = new Array(s.length), p = new Array(), c = s.entries(), d = new Array(i).fill(c).map(async (n) => {
+    for (const [h, l] of n) {
+      r > 0 && await new Promise((u) => setTimeout(u, r));
+      try {
+        o[h] = await t(l);
+      } catch (u) {
+        if (a)
+          throw u;
+        p.push(u);
+      }
+    }
+  });
+  if (await Promise.all(d), !a && p.length > 0)
+    throw new AggregateError(
+      p,
+      "Multiple errors occurred during jules.all()"
+    );
+  return o;
+}
+class $ {
+  /**
+   * Manages source connections (e.g., GitHub repositories).
+   */
+  sources;
+  apiClient;
+  config;
+  options;
+  storageFactory;
+  platform;
+  /**
+   * Creates a new instance of the JulesClient.
+   *
+   * @param options Configuration options for the client.
+   * @param defaultStorageFactory Factory for creating storage instances.
+   * @param defaultPlatform Platform-specific implementation.
+   */
+  constructor(t = {}, e, i) {
+    this.options = t, this.storageFactory = t.storageFactory ?? e, this.platform = t.platform ?? i;
+    const a = t.apiKey ?? process.env.JULES_API_KEY, r = t.baseUrl ?? "https://jules.googleapis.com/v1alpha";
+    this.config = {
+      pollingIntervalMs: t.config?.pollingIntervalMs ?? 5e3,
+      requestTimeoutMs: t.config?.requestTimeoutMs ?? 3e4
+    }, this.apiClient = new U({
+      apiKey: a,
+      baseUrl: r,
+      requestTimeoutMs: this.config.requestTimeoutMs
+    }), this.sources = O(this.apiClient);
+  }
+  /**
+   * Creates a new Jules client instance with updated configuration.
+   * This is an immutable operation; the original client instance remains unchanged.
+   *
+   * @param options The new configuration options to merge with the existing ones.
+   * @returns A new JulesClient instance with the updated configuration.
+   */
+  with(t) {
+    return new $(
+      {
+        ...this.options,
+        ...t,
+        config: {
+          ...this.options.config,
+          ...t.config
+        }
+      },
+      this.storageFactory,
+      this.platform
+    );
+  }
+  async all(t, e, i) {
+    return z(
+      t,
+      async (a) => {
+        const r = await e(a);
+        return this.run(r);
+      },
+      i
+    );
+  }
+  async _prepareSessionCreation(t) {
+    const e = await this.sources.get({ github: t.source.github });
+    if (!e)
+      throw new A(t.source.github);
+    return {
+      prompt: t.prompt,
+      title: t.title,
+      sourceContext: {
+        source: e.name,
+        githubRepoContext: {
+          startingBranch: t.source.branch
+        }
+      }
+    };
+  }
+  /**
+   * Executes a task in automated mode.
+   * This is a high-level abstraction for "fire-and-forget" tasks.
+   *
+   * **Side Effects:**
+   * - Creates a new session on the Jules API (`POST /sessions`).
+   * - Initiates background polling for activity updates.
+   * - May create a Pull Request if `autoPr` is true (default).
+   *
+   * **Data Transformation:**
+   * - Resolves the `github` source identifier (e.g., `owner/repo`) to a full resource name.
+   * - Defaults `requirePlanApproval` to `false` for automated runs.
+   *
+   * @param config The configuration for the run.
+   * @returns A `AutomatedSession` object, which is an enhanced Promise that resolves to the final outcome.
+   * @throws {SourceNotFoundError} If the specified GitHub repository cannot be found or accessed.
+   * @throws {JulesApiError} If the session creation fails (e.g., 401 Unauthorized).
+   *
+   * @example
+   * const run = await jules.run({
+   *   prompt: "Fix the login bug",
+   *   source: { github: "my-org/repo", branch: "main" }
+   * });
+   * const outcome = await run.result();
+   */
+  async run(t) {
+    const e = await this._prepareSessionCreation(t), a = (await this.apiClient.request(
+      "sessions",
+      {
+        method: "POST",
+        body: {
+          ...e,
+          automationMode: t.autoPr === !1 ? "AUTOMATION_MODE_UNSPECIFIED" : "AUTO_CREATE_PR",
+          requirePlanApproval: t.requireApproval ?? !1
+        }
+      }
+    )).id;
+    return {
+      id: a,
+      stream: (async function* () {
+        yield* J(
+          a,
+          this.apiClient,
+          this.config.pollingIntervalMs,
+          this.platform
+        );
+      }).bind(this),
+      result: async () => {
+        const r = await M(
+          a,
+          this.apiClient,
+          this.config.pollingIntervalMs
+        );
+        return b(r);
+      }
+    };
+  }
+  session(t) {
+    if (typeof t == "string") {
+      const a = this.storageFactory(t);
+      return new S(
+        t,
+        this.apiClient,
+        this.config,
+        a,
+        this.platform
+      );
+    }
+    const e = t;
+    return (async () => {
+      const a = await this._prepareSessionCreation(e), r = await this.apiClient.request(
+        "sessions",
+        {
+          method: "POST",
+          body: {
+            ...a,
+            automationMode: "AUTOMATION_MODE_UNSPECIFIED",
+            requirePlanApproval: e.requireApproval ?? !0
+          }
+        }
+      ), o = this.storageFactory(r.id);
+      return new S(
+        r.name,
+        this.apiClient,
+        this.config,
+        o,
+        this.platform
+      );
+    })();
+  }
+}
+export {
+  P as A,
+  q as I,
+  $ as J,
+  I as M,
+  A as S,
+  g as a,
+  k as b,
+  f as c,
+  x as d,
+  E as e
+};