@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-0wjw63yk.js

@@ -0,0 +1,329 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  makeUnsafe2
+} from "./repository-y71avatq.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  SessionEvent2
+} from "./repository-ec1grn59.js";
+import {
+  SessionMessage2
+} from "./repository-gftt206x.js";
+import {
+  SessionSchema2
+} from "./repository-y6f0p4jw.js";
+import {
+  SessionMessageTable2,
+  SessionInboxTable2
+} from "./repository-a1bz86dw.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/inbox.ts
+var exports_inbox = {};
+__export(exports_inbox, {
+  Compaction: () => Compaction2,
+  CompactionPayload: () => CompactionPayload2,
+  Delivery: () => Delivery2,
+  Info: () => Info18,
+  Item: () => Item2,
+  LifecycleConflict: () => LifecycleConflict2,
+  Move: () => Move2,
+  MovePayload: () => MovePayload2,
+  Service: () => Service50,
+  SessionInbox: () => exports_inbox,
+  Synthetic: () => Synthetic2,
+  SyntheticPayload: () => SyntheticPayload2,
+  User: () => User2,
+  UserPayload: () => UserPayload2,
+  find: () => find2,
+  has: () => has2,
+  layer: () => layer21,
+  list: () => list3,
+  make: () => make17,
+  moveIDs: () => moveIDs2,
+  nextPromotable: () => nextPromotable2,
+  node: () => node54,
+  projectAdmitted: () => projectAdmitted2,
+  projectCancelled: () => projectCancelled2,
+  projectDelivered: () => projectDelivered2,
+  projectDeliveryChanged: () => projectDeliveryChanged2,
+  promote: () => promote2,
+  serialized: () => serialized2
+});
+import { and, asc, eq, or } from "drizzle-orm";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import {
+  Compaction as Compaction2,
+  CompactionPayload as CompactionPayload2,
+  Delivery as Delivery2,
+  Info as Info18,
+  Item as Item2,
+  Move as Move2,
+  MovePayload as MovePayload2,
+  Synthetic as Synthetic2,
+  SyntheticPayload as SyntheticPayload2,
+  User as User2,
+  UserPayload as UserPayload2
+} from "@opencode/schema/session-inbox";
+var decodeUser = Schema.decodeUnknownSync(UserPayload2);
+var encodeUser = Schema.encodeSync(UserPayload2);
+var decodeSynthetic = Schema.decodeUnknownSync(SyntheticPayload2);
+var encodeSynthetic = Schema.encodeSync(SyntheticPayload2);
+var decodeCompaction = Schema.decodeUnknownSync(CompactionPayload2);
+var encodeCompaction = Schema.encodeSync(CompactionPayload2);
+var decodeMove = Schema.decodeUnknownSync(MovePayload2);
+var encodeMove = Schema.encodeSync(MovePayload2);
+var decodeMessage = Schema.decodeUnknownSync(SessionMessage2.Info);
+var inboxLocks = makeUnsafe2();
+var serialized2 = (sessionID, effect) => inboxLocks.withLock(sessionID)(effect);
+
+class LifecycleConflict2 extends Schema.TaggedError()("SessionInbox.LifecycleConflict", {
+  id: SessionMessage2.ID
+}) {
+}
+function matches(stored, request) {
+  return stored.sessionID === request.sessionID && stored.type === request.type;
+}
+var fromRow = (row) => {
+  const base = {
+    id: SessionMessage2.ID.make(row.id),
+    sessionID: SessionSchema2.ID.make(row.session_id),
+    timeCreated: DateTime.makeUnsafe(row.time_created)
+  };
+  if (row.type === "compaction")
+    return Compaction2.make({
+      ...base,
+      type: "compaction",
+      payload: decodeCompaction(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "move")
+    return Move2.make({ ...base, type: "move", payload: decodeMove(row.payload), delivery: row.delivery });
+  if (row.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(row.payload),
+      delivery: row.delivery
+    });
+  if (row.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(row.payload),
+      delivery: row.delivery
+    });
+  throw new LifecycleConflict2({ id: base.id });
+};
+var find2 = Effect.fn("SessionInbox.find")(function* (db, id) {
+  const row = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.id, id)).get().pipe(Effect.orDie);
+  return row === undefined ? undefined : fromRow(row);
+});
+var promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(function* (db, sessionID, id, delivery) {
+  const row = yield* db.select().from(SessionMessageTable2).where(eq(SessionMessageTable2.id, id)).get().pipe(Effect.orDie);
+  if (row === undefined)
+    return;
+  if (row.session_id !== sessionID || row.type !== "user" && row.type !== "synthetic")
+    return yield* new LifecycleConflict2({ id });
+  const message = decodeMessage({ ...row.data, id: row.id, type: row.type });
+  const base = { id, sessionID, timeCreated: message.time.created, delivery };
+  if (message.type === "user")
+    return User2.make({
+      ...base,
+      type: "user",
+      payload: decodeUser(message)
+    });
+  if (message.type === "synthetic")
+    return Synthetic2.make({
+      ...base,
+      type: "synthetic",
+      payload: decodeSynthetic(message)
+    });
+  return yield* new LifecycleConflict2({ id });
+});
+
+class Service50 extends Context.Service()("@opencode/SessionInbox") {
+}
+var make17 = Effect.fn("SessionInbox.make")(function* () {
+  const database = yield* Service79;
+  const db = database.db;
+  const bus = yield* Service78;
+  const reconcile = Effect.fn("SessionInbox.reconcile")(function* (request) {
+    const existing = (yield* find2(db, request.id)) ?? (yield* promotedFromMessage(db, request.sessionID, request.id, request.delivery));
+    if (existing === undefined)
+      return;
+    if (existing.type === "compaction" || !matches(existing, request))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return existing;
+  });
+  const admit = Effect.fn("SessionInbox.admit")(function* (request) {
+    const existing = yield* reconcile({ ...request, type: request.item.type, delivery: request.item.delivery });
+    if (existing !== undefined)
+      return existing;
+    const admitted = yield* bus.publish(SessionEvent2.InboxEnqueued, {
+      inboxID: request.id,
+      sessionID: request.sessionID,
+      item: request.item
+    }).pipe(Effect.map((event) => Info18.make({
+      id: request.id,
+      sessionID: request.sessionID,
+      timeCreated: DateTime.makeUnsafe(event.created),
+      ...request.item
+    })), Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? find2(db, request.id).pipe(Effect.flatMap((stored) => stored === undefined ? Effect.fail(defect) : Effect.succeed(stored))) : Effect.die(defect)));
+    if (!matches(admitted, { ...request, type: request.item.type }))
+      return yield* new LifecycleConflict2({ id: request.id });
+    return admitted;
+  });
+  const admitCompaction = Effect.fn("SessionInbox.admitCompaction")(function* (input) {
+    return yield* serialized2(input.sessionID, Effect.gen(function* () {
+      const exact = yield* find2(db, input.id);
+      if (exact) {
+        if (exact.type === "compaction" && exact.sessionID === input.sessionID)
+          return exact;
+        return yield* new LifecycleConflict2({ id: input.id });
+      }
+      if (yield* promotedFromMessage(db, input.sessionID, input.id, input.delivery))
+        return yield* new LifecycleConflict2({ id: input.id });
+      const pending = (yield* list3(db, input.sessionID)).find((item) => item.type === "compaction");
+      if (pending)
+        return pending;
+      return yield* admit({
+        id: input.id,
+        sessionID: input.sessionID,
+        item: { type: "compaction", payload: {}, delivery: Delivery2.make(input.delivery) }
+      });
+    }));
+  });
+  const cancel = Effect.fn("SessionInbox.cancel")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxCancelled, {
+    sessionID: input.sessionID,
+    inboxID: input.id
+  })));
+  const steer = Effect.fn("SessionInbox.steer")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "steer"
+  })));
+  const queue = Effect.fn("SessionInbox.queue")((input) => publishMutation(input, bus.publish(SessionEvent2.InboxDeliveryChanged, {
+    sessionID: input.sessionID,
+    inboxID: input.id,
+    delivery: "queue"
+  })));
+  return {
+    list: (sessionID) => list3(db, sessionID),
+    reconcile,
+    admit,
+    admitCompaction,
+    cancel,
+    steer,
+    queue
+  };
+});
+var layer21 = Layer.effect(Service50, make17());
+var node54 = makeGlobalNode({ service: Service50, layer: layer21, deps: [node84, node83] });
+var projectAdmitted2 = Effect.fn("SessionInbox.projectAdmitted")(function* (db, request) {
+  const message = yield* db.select({ id: SessionMessageTable2.id }).from(SessionMessageTable2).where(eq(SessionMessageTable2.id, request.id)).get().pipe(Effect.orDie);
+  if (message !== undefined)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+  const stored = yield* db.insert(SessionInboxTable2).values({
+    id: request.id,
+    session_id: request.sessionID,
+    type: request.item.type,
+    payload: request.item.type === "user" ? encodeUser(request.item.payload) : request.item.type === "synthetic" ? encodeSynthetic(request.item.payload) : request.item.type === "compaction" ? encodeCompaction(request.item.payload) : encodeMove(request.item.payload),
+    delivery: request.item.delivery,
+    enqueued_seq: request.enqueuedSeq,
+    time_created: request.timeCreated
+  }).onConflictDoNothing().returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!stored)
+    return yield* Effect.die(new LifecycleConflict2({ id: request.id }));
+});
+var projectDelivered2 = Effect.fn("SessionInbox.projectDelivered")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID))).returning().get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+  return fromRow(deleted);
+});
+var projectCancelled2 = Effect.fn("SessionInbox.projectCancelled")(function* (db, input) {
+  const deleted = yield* db.delete(SessionInboxTable2).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), or(eq(SessionInboxTable2.delivery, "queue"), eq(SessionInboxTable2.delivery, "steer")))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!deleted)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDelivery = Effect.fn("SessionInbox.projectDelivery")(function* (db, input) {
+  const updated = yield* db.update(SessionInboxTable2).set({ delivery: input.to }).where(and(eq(SessionInboxTable2.id, input.id), eq(SessionInboxTable2.session_id, input.sessionID), eq(SessionInboxTable2.delivery, input.from))).returning({ id: SessionInboxTable2.id }).get().pipe(Effect.orDie);
+  if (!updated)
+    return yield* Effect.die(new LifecycleConflict2({ id: input.id }));
+});
+var projectDeliveryChanged2 = Effect.fn("SessionInbox.projectDeliveryChanged")((db, input) => projectDelivery(db, {
+  ...input,
+  from: input.delivery === "steer" ? "queue" : "steer",
+  to: input.delivery
+}));
+var list3 = Effect.fn("SessionInbox.list")(function* (db, sessionID) {
+  const rows = yield* db.select().from(SessionInboxTable2).where(eq(SessionInboxTable2.session_id, sessionID)).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+  return rows.map(fromRow);
+});
+var moveIDs2 = Effect.fn("SessionInbox.moveIDs")(function* (db, sessionID) {
+  return yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.type, "move"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie);
+});
+var nextPromotable2 = Effect.fn("SessionInbox.nextPromotable")(function* (db, sessionID, promotable) {
+  const steer = (yield* pendingSteers(db, sessionID))[0];
+  if (steer)
+    return fromRow(steer);
+  if (promotable !== "input")
+    return;
+  const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+  return queued ? fromRow(queued) : undefined;
+});
+var has2 = Effect.fn("SessionInbox.has")(function* (db, sessionID, scope) {
+  const row = yield* db.select({ id: SessionInboxTable2.id }).from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), scope === "input" ? or(eq(SessionInboxTable2.delivery, "steer"), eq(SessionInboxTable2.delivery, "queue")) : eq(SessionInboxTable2.delivery, scope))).limit(1).get().pipe(Effect.orDie);
+  return row !== undefined;
+});
+var publishMutation = (input, effect) => serialized2(input.sessionID, effect).pipe(Effect.asVoid, Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? Effect.fail(defect) : Effect.die(defect)));
+var publish = Effect.fn("SessionInbox.publish")(function* (db, bus, sessionID, rows) {
+  yield* Effect.forEach(rows, (row) => {
+    const entry = fromRow(row);
+    if (entry.type === "compaction")
+      return Effect.die(new LifecycleConflict2({ id: entry.id }));
+    return bus.publish(SessionEvent2.InboxDelivered, {
+      sessionID,
+      inboxID: entry.id
+    }).pipe(Effect.catchDefect((defect) => defect instanceof LifecycleConflict2 ? promotedFromMessage(db, sessionID, entry.id, entry.delivery).pipe(Effect.flatMap((stored) => stored !== undefined ? Effect.void : Effect.die(defect)), Effect.orDie) : Effect.die(defect)));
+  }, { discard: true });
+  return rows.length;
+});
+var promote2 = Effect.fn("SessionInbox.promote")(function* (db, bus, sessionID, scope) {
+  return yield* serialized2(sessionID, Effect.gen(function* () {
+    const steers = yield* pendingSteers(db, sessionID);
+    if (steers.length > 0 || scope === "steer") {
+      const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move");
+      if (control === 0)
+        return;
+      return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control));
+    }
+    const queued = yield* db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "queue"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).limit(1).get().pipe(Effect.orDie);
+    if (!queued)
+      return 0;
+    if (queued.type === "compaction" || queued.type === "move")
+      return;
+    const promoted = yield* publish(db, bus, sessionID, [queued]);
+    const arrivedSteers = yield* pendingSteers(db, sessionID);
+    const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move");
+    return promoted + (yield* publish(db, bus, sessionID, control === -1 ? arrivedSteers : arrivedSteers.slice(0, control)));
+  }));
+});
+var pendingSteers = (db, sessionID) => db.select().from(SessionInboxTable2).where(and(eq(SessionInboxTable2.session_id, sessionID), eq(SessionInboxTable2.delivery, "steer"))).orderBy(asc(SessionInboxTable2.enqueued_seq)).all().pipe(Effect.orDie, Effect.map((rows) => {
+  const control = rows.findIndex((row) => row.type === "compaction" || row.type === "move");
+  if (control > 0 && rows[control].type === "compaction")
+    rows.unshift(...rows.splice(control, 1));
+  return rows;
+}));
+
+export { Compaction2, CompactionPayload2, Delivery2, Info18, Item2, Move2, MovePayload2, Synthetic2, SyntheticPayload2, User2, UserPayload2, serialized2, LifecycleConflict2, find2, Service50, make17, layer21, node54, projectAdmitted2, projectDelivered2, projectCancelled2, projectDeliveryChanged2, list3, moveIDs2, nextPromotable2, has2, promote2, exports_inbox };

package/dist/chunks/repository-0xfnng1h.js

@@ -0,0 +1,318 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  OAuth3,
+  Event19
+} from "./repository-sztg2hv4.js";
+import {
+  ID13,
+  MethodID2
+} from "./repository-0zkv00cg.js";
+import {
+  success2,
+  error2
+} from "./repository-pjvnvgmy.js";
+import {
+  ID16,
+  mergeOverlay2,
+  mergeHeaders2
+} from "./repository-pye8sh6e.js";
+
+// src/plugin/provider/openai.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Deferred, Effect, Option, Schema, Semaphore, Stream } from "effect";
+var clientID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var issuer = "https://auth.openai.com";
+var callbackPort = 1455;
+var callbackFallbackPort = 1457;
+var callbackBindAttempts = 10;
+var callbackBindRetryDelay = 200;
+var pollingSafetyMargin = 3000;
+var codexBaseURL = "https://chatgpt.com/backend-api/codex";
+var browserMethodID = MethodID2.make("chatgpt-browser");
+var headlessMethodID = MethodID2.make("chatgpt-headless");
+var codexAllowed = new Set(["gpt-5.5", "gpt-5.3-codex-spark"]);
+var codexDisallowed = new Set(["gpt-5.5-pro", "gpt-5.6"]);
+var Claims = Schema.fromJsonString(Schema.Struct({
+  chatgpt_account_id: Schema.optional(Schema.String),
+  organizations: Schema.optional(Schema.Array(Schema.Struct({ id: Schema.String }))),
+  "https://api.openai.com/auth": Schema.optional(Schema.Struct({ chatgpt_account_id: Schema.optional(Schema.String) }))
+}));
+var decodeClaims = Schema.decodeUnknownOption(Claims);
+var browser = (app) => ({
+  integrationID: ID13.make("openai"),
+  method: {
+    id: browserMethodID,
+    type: "oauth",
+    label: "ChatGPT Pro/Plus (browser)"
+  },
+  authorize: () => Effect.gen(function* () {
+    const pkce = yield* Effect.promise(generatePKCE);
+    const state = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+    const code = yield* Deferred.make();
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://localhost");
+      if (url.pathname !== "/auth/callback") {
+        response.writeHead(404).end("Not found");
+        return;
+      }
+      const error = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+      const value = url.searchParams.get("code");
+      if (error) {
+        Effect.runFork(Deferred.fail(code, new Error(error)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(error, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!value || url.searchParams.get("state") !== state) {
+        const message = value ? "Invalid OAuth state" : "Missing authorization code";
+        Effect.runFork(Deferred.fail(code, new Error(message)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(message, { provider: "ChatGPT" }));
+        return;
+      }
+      Effect.runFork(Deferred.succeed(code, value));
+      response.writeHead(200, { "Content-Type": "text/html" }).end(success2({ provider: "ChatGPT" }));
+    });
+    const port = yield* listen(server);
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    const redirect = `http://localhost:${port}/auth/callback`;
+    return {
+      mode: "auto",
+      url: authorizeURL(redirect, pkce, state),
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Deferred.await(code).pipe(Effect.flatMap((value) => exchange(value, redirect, pkce, app)), Effect.map((tokens) => credential(browserMethodID, tokens)))
+    };
+  }),
+  refresh: (value) => refresh(browserMethodID, value, app)
+});
+function listen(server) {
+  return bind(server, callbackPort).pipe(Effect.as(callbackPort), Effect.catchIf(addressInUse, () => cancel(callbackPort).pipe(Effect.ignore, Effect.andThen(Effect.sleep(callbackBindRetryDelay)), Effect.andThen(bindWithRetry(server, callbackPort, callbackBindAttempts - 1)), Effect.as(callbackPort), Effect.catchIf(addressInUse, () => bindWithRetry(server, callbackFallbackPort, callbackBindAttempts).pipe(Effect.as(callbackFallbackPort), Effect.catchIf(addressInUse, () => Effect.fail(new Error(`OpenAI browser login needs local port ${callbackPort} or ${callbackFallbackPort}, but both are already in use. Stop the processes using those ports or choose ChatGPT Pro/Plus (headless), then try again.`))))))));
+}
+function bindWithRetry(server, port, attempts) {
+  return bind(server, port).pipe(Effect.catchIf((error) => addressInUse(error) && attempts > 1, () => Effect.sleep(callbackBindRetryDelay).pipe(Effect.andThen(bindWithRetry(server, port, attempts - 1)))));
+}
+function bind(server, port) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(port, "localhost", () => {
+      server.off("error", onError);
+      resume(Effect.void);
+    });
+  });
+}
+function cancel(port) {
+  return Effect.tryPromise({
+    try: (signal) => fetch(`http://localhost:${port}/cancel`, {
+      signal: AbortSignal.any([signal, AbortSignal.timeout(2000)])
+    }),
+    catch: (cause) => cause
+  });
+}
+function addressInUse(error) {
+  return "code" in error && error.code === "EADDRINUSE";
+}
+var headless = (app) => ({
+  integrationID: ID13.make("openai"),
+  method: {
+    id: headlessMethodID,
+    type: "oauth",
+    label: "ChatGPT Pro/Plus (headless)"
+  },
+  authorize: () => Effect.gen(function* () {
+    const device = yield* request(`${issuer}/api/accounts/deviceauth/usercode`, {
+      method: "POST",
+      headers: headers("application/json", app),
+      body: JSON.stringify({ client_id: clientID })
+    });
+    const interval = Math.max(Number.parseInt(device.interval) || 5, 1) * 1000;
+    return {
+      mode: "auto",
+      url: `${issuer}/codex/device`,
+      instructions: `Enter code: ${device.user_code}`,
+      callback: Effect.gen(function* () {
+        while (true) {
+          const response = yield* Effect.tryPromise({
+            try: (signal) => fetch(`${issuer}/api/accounts/deviceauth/token`, {
+              method: "POST",
+              headers: headers("application/json", app),
+              body: JSON.stringify({ device_auth_id: device.device_auth_id, user_code: device.user_code }),
+              signal
+            }),
+            catch: (cause) => cause
+          });
+          if (response.ok) {
+            const data = yield* Effect.promise(() => response.json());
+            return credential(headlessMethodID, yield* exchange(data.authorization_code, `${issuer}/deviceauth/callback`, { verifier: data.code_verifier, challenge: "" }, app));
+          }
+          if (response.status !== 403 && response.status !== 404) {
+            return yield* Effect.fail(new Error(`Device authorization failed: ${response.status}`));
+          }
+          yield* Effect.sleep(interval + pollingSafetyMargin);
+        }
+      })
+    };
+  }),
+  refresh: (value) => refresh(headlessMethodID, value, app)
+});
+var OpenAIPlugin2 = define({
+  id: "opencode.provider.openai",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service78;
+    const loading = Semaphore.makeUnsafe(1);
+    let chatgpt;
+    const load = Effect.fn("OpenAIPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("openai");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      chatgpt = credential?.type === "oauth" && (credential.methodID === browserMethodID || credential.methodID === headlessMethodID) ? credential : undefined;
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update(browser(ctx.app));
+      editor.method.update(headless(ctx.app));
+    });
+    yield* load();
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(ID16.openai);
+      if (!item)
+        return;
+      for (const model of item.models.values()) {
+        evt.model.update(item.provider.id, model.id, (draft) => {
+          draft.capabilities.responsesWebsockets = true;
+          draft.websocket = true;
+        });
+      }
+      if (!chatgpt)
+        return;
+      item.provider.settings = mergeOverlay2(item.provider.settings, { baseURL: codexBaseURL });
+      const account = chatgpt.metadata?.accountID;
+      item.provider.headers = mergeHeaders2(item.provider.headers, {
+        originator: "opencode",
+        "x-codex-beta-features": "remote_compaction_v2",
+        ...typeof account === "string" ? { "chatgpt-account-id": account } : {}
+      });
+      for (const model of item.models.values()) {
+        evt.model.update(item.provider.id, model.id, (draft) => {
+          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
+            draft.enabled = false;
+            return;
+          }
+          const apiID = draft.modelID ?? draft.id;
+          const match = apiID.match(/^gpt-(\d+)(?:\.(\d+))?/);
+          const major = Number(match?.[1]);
+          const minor = Number(match?.[2] ?? 0);
+          if (!codexAllowed.has(apiID) && (codexDisallowed.has(apiID) || !match || !(major > 5 || major === 5 && minor > 4))) {
+            draft.enabled = false;
+            return;
+          }
+          draft.cost = [];
+          draft.limit = { ...draft.limit, context: 400000, input: 272000 };
+        });
+      }
+    });
+    yield* ctx.session.hook("model.request", (evt) => Effect.sync(() => {
+      if (!chatgpt)
+        return;
+      if (evt.baseURL && URL.canParse(evt.baseURL) && new URL(evt.baseURL).origin === "https://api.openai.com")
+        evt.baseURL = codexBaseURL;
+      evt.headers.originator = "opencode";
+      evt.headers["session-id"] = evt.sessionID;
+    }), { providerID: ID16.openai });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID13.make("openai")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function headers(contentType, app) {
+  return { "Content-Type": contentType, "User-Agent": useragent2(app) };
+}
+function exchange(code, redirect, pkce, app) {
+  return request(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: headers("application/x-www-form-urlencoded", app),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirect,
+      client_id: clientID,
+      code_verifier: pkce.verifier
+    }).toString()
+  });
+}
+function refresh(methodID, value, app) {
+  return request(`${issuer}/oauth/token`, {
+    method: "POST",
+    headers: headers("application/x-www-form-urlencoded", app),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID
+    }).toString()
+  }).pipe(Effect.map((tokens) => {
+    const next = credential(methodID, tokens);
+    return OAuth3.make({ ...next, metadata: next.metadata ?? value.metadata });
+  }));
+}
+function request(url, init) {
+  return Effect.tryPromise({
+    try: async (signal) => {
+      const response = await fetch(url, { ...init, signal });
+      if (!response.ok)
+        throw new Error(`Request failed: ${response.status}`);
+      return response.json();
+    },
+    catch: (cause) => cause
+  });
+}
+function credential(methodID, tokens) {
+  const accountID = extractAccountID(tokens);
+  return OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh: tokens.refresh_token,
+    access: tokens.access_token,
+    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+    metadata: accountID ? { accountID } : undefined
+  });
+}
+async function generatePKCE() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const verifier = Array.from(crypto.getRandomValues(new Uint8Array(43)), (byte) => chars[byte % chars.length]).join("");
+  const challenge = base64UrlEncode(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier)));
+  return { verifier, challenge };
+}
+function base64UrlEncode(buffer) {
+  return Buffer.from(buffer).toString("base64url");
+}
+function authorizeURL(redirect, pkce, state) {
+  return `${issuer}/oauth/authorize?${new URLSearchParams({
+    response_type: "code",
+    client_id: clientID,
+    redirect_uri: redirect,
+    scope: "openid profile email offline_access",
+    code_challenge: pkce.challenge,
+    code_challenge_method: "S256",
+    id_token_add_organizations: "true",
+    codex_cli_simplified_flow: "true",
+    state,
+    originator: "opencode"
+  })}`;
+}
+function extractAccountID(tokens) {
+  return claim(tokens.id_token) ?? claim(tokens.access_token);
+}
+function claim(token) {
+  const part = token.split(".")[1];
+  if (!part)
+    return;
+  const claims = Option.getOrUndefined(decodeClaims(Buffer.from(part, "base64url").toString()));
+  if (!claims)
+    return;
+  return claims.chatgpt_account_id ?? claims["https://api.openai.com/auth"]?.chatgpt_account_id ?? claims.organizations?.[0]?.id;
+}
+
+export { OpenAIPlugin2 };