@opencode/core 2.0.18 → 2.0.20

package/dist/chunks/credential-wtjjgayy.js

@@ -0,0 +1,427 @@
+import {
+  useragent2
+} from "./credential-z1qbwb2j.js";
+import {
+  Service82
+} from "./credential-bnqp8nta.js";
+import {
+  ID15,
+  OAuth3,
+  Event19,
+  Service77
+} from "./credential-nbajkkwv.js";
+import {
+  key2
+} from "./credential-dnxkq42g.js";
+import {
+  ID14,
+  MethodID2
+} from "./credential-wp4r7acg.js";
+import {
+  ID13,
+  mergeOverlay2
+} from "./credential-sknxvkc8.js";
+import {
+  ID12,
+  VariantID2,
+  Info26
+} from "./credential-drnx3qwb.js";
+import {
+  success2,
+  error2
+} from "./credential-pjvnvgmy.js";
+
+// src/plugin/provider/chatgpt.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Deferred, Duration, Effect, Option, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var registrationClientID = "dynamic_agent_client";
+var agentName = "OpenCode";
+var issuer = "https://auth.openai.com";
+var tokenURL = `${issuer}/api/accounts/oauth/token`;
+var resource = "https://api.openai.com/v1";
+var tokenSharingScope = "chatgpt.tokens.use.direct";
+var providerID = ID13.openai;
+var integrationID = ID14.make("openai");
+var methodID = MethodID2.make("chatgpt-token-sharing");
+var modelCacheKey = (clientID) => `models:${clientID}`;
+var fallbackModels = new Set([
+  "gpt-5.5",
+  "gpt-5.5-fast",
+  "gpt-5.6-luna",
+  "gpt-5.6-luna-fast",
+  "gpt-5.6-sol",
+  "gpt-5.6-sol-fast",
+  "gpt-5.6-terra",
+  "gpt-5.6-terra-fast",
+  "gpt-6-astra",
+  "gpt-6-astra-fast"
+]);
+var nonRetryableSharingCodes = [
+  "subscription_sharing_usage_limit_exceeded",
+  "subscription_sharing_user_not_eligible",
+  "subscription_sharing_unsupported_capability",
+  "subscription_sharing_route_not_supported",
+  "subscription_sharing_invalid_user",
+  "chatpass_v2_scope_not_authorized",
+  "chatpass_v2_invalid_authorization_context"
+];
+var RemoteModel = Schema.Struct({
+  slug: Schema.String,
+  display_name: Schema.String,
+  visibility: Schema.String,
+  supported_in_api: Schema.Boolean,
+  context_window: Schema.Int.check(Schema.isGreaterThan(1)),
+  input_modalities: Schema.Array(Schema.String),
+  supported_reasoning_levels: Schema.optional(Schema.Array(Schema.Struct({ effort: Schema.String })))
+});
+var RemoteModels = Schema.Struct({ models: Schema.Array(RemoteModel) });
+var decodeCachedModels = Schema.decodeUnknownOption(Schema.Array(RemoteModel));
+var decodeMetadata = Schema.decodeUnknownOption(Schema.Struct({
+  clientID: Schema.String,
+  scopes: Schema.optional(Schema.Array(Schema.String)),
+  models: Schema.optional(Schema.Array(RemoteModel))
+}));
+var signIn = (app, savedClientID, storage) => ({
+  integrationID,
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Sign in with ChatGPT"
+  },
+  authorize: () => Effect.gen(function* () {
+    const storedHostID = yield* storage.get("chatgpt-agent-host-id");
+    const hostID = typeof storedHostID === "string" ? storedHostID : `urn:uuid:${crypto.randomUUID()}`;
+    if (typeof storedHostID !== "string")
+      yield* storage.set("chatgpt-agent-host-id", hostID);
+    const pkce = yield* Effect.promise(generatePKCE);
+    const state = randomValue();
+    const nonce = randomValue();
+    const savedID = savedClientID();
+    const received = yield* Deferred.make();
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://127.0.0.1");
+      if (url.pathname !== "/auth/callback") {
+        response.writeHead(404).end("Not found");
+        return;
+      }
+      const error = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+      const authorizationCode = url.searchParams.get("code");
+      if (error) {
+        Effect.runFork(Deferred.fail(received, new Error(error)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(error, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!authorizationCode || url.searchParams.get("state") !== state) {
+        const message = authorizationCode ? "Invalid OAuth state" : "Missing authorization code";
+        Effect.runFork(Deferred.fail(received, new Error(message)));
+        response.writeHead(400, { "Content-Type": "text/html" }).end(error2(message, { provider: "ChatGPT" }));
+        return;
+      }
+      if (!Effect.runSync(Deferred.succeed(received, {
+        code: authorizationCode,
+        clientID: url.searchParams.get("client_id") ?? undefined,
+        response
+      })))
+        response.writeHead(409).end("OAuth callback already received");
+    });
+    const port = yield* listen(server);
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    const redirect = `http://127.0.0.1:${port}/auth/callback`;
+    return {
+      mode: "auto",
+      url: authorizeURL(redirect, pkce, state, nonce, savedID, hostID),
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Effect.gen(function* () {
+        const result = yield* Deferred.await(received);
+        const respond = (error) => Effect.sync(() => result.response.writeHead(error ? 400 : 200, { "Content-Type": "text/html" }).end(error ? error2(error, { provider: "ChatGPT" }) : success2({ provider: "ChatGPT" })));
+        return yield* Effect.gen(function* () {
+          if (savedID && result.clientID && result.clientID !== savedID)
+            return yield* Effect.fail(new Error("ChatGPT returned a different client than this connection. Connect again."));
+          const clientID = savedID ?? result.clientID;
+          if (!clientID)
+            return yield* Effect.fail(new Error("ChatGPT sign-in did not return a client ID. Connect again."));
+          const tokens = yield* exchange(result.code, clientID, redirect, pkce, app);
+          if (!tokens.scope?.split(" ").includes(tokenSharingScope))
+            return yield* Effect.fail(new Error("ChatGPT sign-in finished without token sharing. Sign in again and allow token sharing, or connect OpenAI with an API key."));
+          if (!tokens.id_token)
+            return yield* Effect.fail(new Error("ChatGPT sign-in did not return an ID token."));
+          yield* verifyIDToken2(tokens.id_token, clientID, nonce);
+          return credential(tokens, clientID);
+        }).pipe(Effect.tap(() => respond()), Effect.tapError((error) => respond(error instanceof Error ? error.message : "ChatGPT sign-in failed")), Effect.onInterrupt(() => Effect.sync(() => result.response.destroy())));
+      })
+    };
+  }),
+  refresh: (value) => refresh(value, app)
+});
+function listen(server) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onError);
+      const address = server.address();
+      if (!address || typeof address === "string")
+        return resume(Effect.fail(new Error("Missing OAuth callback port")));
+      resume(Effect.succeed(address.port));
+    });
+  });
+}
+var ChatGPTPlugin2 = define({
+  id: "opencode.provider.chatgpt",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service82;
+    const credentials = yield* Service77;
+    const loading = Semaphore.makeUnsafe(1);
+    let chatgpt;
+    let available;
+    let source;
+    const load = Effect.fn("ChatGPTPlugin.load")(function* () {
+      const previous = key2(source);
+      const connection = yield* ctx.integration.connection.active(integrationID);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      chatgpt = credential?.type === "oauth" && credential.methodID === methodID ? credential : undefined;
+      source = chatgpt ? connection : undefined;
+      if (previous !== key2(source)) {
+        const metadata = Option.getOrUndefined(decodeMetadata(chatgpt?.metadata));
+        const stored = metadata ? yield* ctx.storage.get(modelCacheKey(metadata.clientID)) : undefined;
+        available = Option.getOrUndefined(decodeCachedModels(stored));
+      }
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update(signIn(ctx.app, () => Option.getOrUndefined(decodeMetadata(chatgpt?.metadata))?.clientID, ctx.storage));
+    });
+    yield* Effect.forEach(yield* credentials.list(ID14.make("openai")), (entry) => {
+      const value = entry.value;
+      if (value.type !== "oauth" || value.methodID !== MethodID2.make("chatgpt-browser"))
+        return Effect.void;
+      const metadata = Option.getOrUndefined(decodeMetadata(value.metadata));
+      if (!metadata)
+        return Effect.void;
+      return Effect.gen(function* () {
+        const saved = yield* ctx.storage.get(modelCacheKey(metadata.clientID));
+        if (!Option.isSome(decodeCachedModels(saved)) && metadata.models)
+          yield* ctx.storage.set(modelCacheKey(metadata.clientID), metadata.models);
+        const { models: _, ...rest } = value.metadata ?? {};
+        yield* credentials.update(entry.id, {
+          value: OAuth3.make({ ...value, methodID, metadata: rest })
+        });
+      });
+    }, { discard: true });
+    yield* load();
+    yield* ctx.session.hook("retry", (event) => Effect.sync(() => {
+      if (!chatgpt || !nonRetryableSharingCodes.some((code) => event.error.response?.body.includes(code)))
+        return;
+      event.decision = { retry: false };
+    }), { providerID });
+    yield* ctx.provider.transform((providers) => {
+      const item = providers.get(providerID);
+      if (!item)
+        return;
+      if (!chatgpt || !source)
+        return;
+      providers.update(providerID, (provider) => {
+        provider.settings = mergeOverlay2(provider.settings, {
+          baseURL: resource,
+          transport: "http",
+          compaction: { type: "summary" }
+        });
+      });
+      const updated = providers.get(providerID);
+      if (!updated)
+        return;
+      providers.add({
+        info: updated.provider,
+        models: available ? deriveModels2(available, Array.from(item.models.values())) : Array.from(item.models.values()).filter((model) => fallbackModels.has(model.id)),
+        sourceConnection: source
+      });
+    });
+    yield* ctx.model.transform((models) => {
+      for (const model of models.list(providerID)) {
+        models.update(model.providerID, model.id, (draft) => {
+          if (!chatgpt)
+            return;
+          draft.settings = { ...draft.settings, compaction: { type: "summary" } };
+          if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(draft.body?.reasoning)) {
+            draft.enabled = false;
+            return;
+          }
+          if (available && !available.some((remote) => remote.slug === (draft.modelID ?? draft.id))) {
+            draft.enabled = false;
+            return;
+          }
+          draft.cost = [];
+        });
+      }
+    });
+    const refreshModels = Effect.fn("ChatGPTPlugin.refreshModels")(function* () {
+      const connection = source;
+      const credential = connection?.type === "credential" ? (yield* credentials.get(ID15.make(connection.id)))?.value : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID || credential.expires <= Date.now() + 60000)
+        return;
+      const metadata = Option.getOrUndefined(decodeMetadata(credential.metadata));
+      if (!metadata)
+        return;
+      const models = yield* fetchModels2(credential.access, ctx.app).pipe(Effect.timeout(15000), Effect.catch(() => Effect.logWarning("failed to refresh ChatGPT models").pipe(Effect.as(undefined))));
+      if (!models)
+        return;
+      yield* loading.withPermit(Effect.gen(function* () {
+        if (key2(connection) !== key2(source) || key2(connection) !== key2(yield* ctx.integration.connection.active(integrationID)))
+          return;
+        if (JSON.stringify(models) === JSON.stringify(available))
+          return;
+        yield* ctx.storage.set(modelCacheKey(metadata.clientID), models);
+        available = models;
+        yield* ctx.provider.reload();
+      }));
+    });
+    const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.provider.reload()))).pipe(Effect.andThen(refreshModels().pipe(Effect.forkScoped, Effect.asVoid)));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === integrationID), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* refreshModels().pipe(Effect.forkScoped);
+    yield* Effect.sleep(Duration.minutes(15)).pipe(Effect.andThen(refreshModels), Effect.forever, Effect.forkScoped);
+  })
+});
+function headers(app) {
+  return { "Content-Type": "application/x-www-form-urlencoded", "User-Agent": useragent2(app) };
+}
+function exchange(code, clientID, redirect, pkce, app) {
+  return request(tokenURL, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: clientID,
+      code,
+      code_verifier: pkce.verifier,
+      redirect_uri: redirect,
+      resource
+    }).toString()
+  });
+}
+function refresh(value, app) {
+  return Effect.gen(function* () {
+    const metadata = Option.getOrUndefined(decodeMetadata(value.metadata));
+    if (!metadata)
+      return yield* Effect.fail(new Error("This ChatGPT connection has no registered client ID. Connect again."));
+    const tokens = yield* request(tokenURL, {
+      method: "POST",
+      headers: headers(app),
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        client_id: metadata.clientID,
+        refresh_token: value.refresh,
+        resource
+      }).toString()
+    });
+    return credential(tokens, metadata.clientID, metadata.scopes);
+  });
+}
+function fetchModels2(token, app, baseURL = resource) {
+  return Effect.gen(function* () {
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const response = yield* http.execute(HttpClientRequest.get(`${baseURL}/models`).pipe(HttpClientRequest.bearerToken(token), HttpClientRequest.setHeader("User-Agent", useragent2(app))));
+    const data = yield* HttpClientResponse.schemaBodyJson(RemoteModels)(response);
+    const models = data.models.filter((model) => model.visibility === "list" && model.supported_in_api);
+    if (!models.length)
+      return yield* Effect.fail(new Error("No ChatGPT models are available for this account."));
+    return models;
+  });
+}
+function deriveModels2(remote, existing) {
+  const byID = new Map(remote.map((model) => [model.slug, model]));
+  const known = new Set(existing.map((model) => model.id));
+  return [
+    ...existing.flatMap((model) => {
+      const found = byID.get(model.modelID);
+      return found ? [deriveModel(found, model)] : [];
+    }),
+    ...remote.filter((model) => !known.has(ID12.make(model.slug))).map((model) => deriveModel(model, Info26.default(ID13.openai, ID12.make(model.slug))))
+  ];
+}
+function deriveModel(remote, previous) {
+  return {
+    ...previous,
+    name: previous.id === previous.modelID ? remote.display_name : previous.name,
+    package: previous.package ?? "@opencode/ai/providers/openai",
+    capabilities: {
+      ...previous.capabilities,
+      input: remote.input_modalities.filter((modality) => modality === "text" || modality === "image")
+    },
+    variants: [
+      ...previous.variants.filter((variant) => typeof variant.settings?.reasoningEffort !== "string"),
+      ...(remote.supported_reasoning_levels ?? []).map(({ effort }) => previous.variants.find((variant) => variant.id === effort && variant.settings?.reasoningEffort === effort) ?? { id: VariantID2.make(effort), settings: { reasoningEffort: effort } })
+    ],
+    limit: { context: remote.context_window, output: previous.limit.output }
+  };
+}
+function verifyIDToken2(token, clientID, nonce, jwksURL = new URL(`${issuer}/.well-known/jwks.json`)) {
+  return Effect.tryPromise({
+    try: async () => {
+      const { createRemoteJWKSet, jwtVerify } = await import("jose");
+      const { payload } = await jwtVerify(token, createRemoteJWKSet(jwksURL), {
+        issuer,
+        audience: clientID,
+        algorithms: ["RS256"],
+        requiredClaims: ["exp", "nonce", "sub"]
+      });
+      if (typeof payload.sub !== "string" || !payload.sub.trim())
+        throw new Error("ID token subject is missing");
+      if (payload.nonce !== nonce)
+        throw new Error("ID token nonce does not match this sign-in attempt");
+    },
+    catch: (cause) => new Error("ChatGPT sign-in returned an invalid ID token.", { cause })
+  });
+}
+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(tokens, clientID, scopes) {
+  return OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh: tokens.refresh_token,
+    access: tokens.access_token,
+    expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+    metadata: { clientID, scopes: tokens.scope?.split(" ").filter(Boolean) ?? scopes ?? [] }
+  });
+}
+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 randomValue() {
+  return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+}
+function base64UrlEncode(buffer) {
+  return Buffer.from(buffer).toString("base64url");
+}
+function authorizeURL(redirect, pkce, state, nonce, savedID, hostID) {
+  return `${issuer}/api/accounts/authorize?${new URLSearchParams({
+    client_id: savedID ?? registrationClientID,
+    ...savedID ? {} : { agent_name_hint: agentName },
+    ext_agent_host_id: hostID,
+    response_type: "code",
+    redirect_uri: redirect,
+    scope: `openid profile email offline_access resource.invoke ${tokenSharingScope}`,
+    resource,
+    state,
+    nonce,
+    code_challenge_method: "S256",
+    code_challenge: pkce.challenge
+  })}`;
+}
+
+export { ChatGPTPlugin2, fetchModels2, deriveModels2, verifyIDToken2 };

package/dist/chunks/{config-817kbg2h.js → credential-x01zr8y0.js}

@@ -1,50 +1,50 @@
 import {
-  Service65
-} from "./config-954548m7.js";
+  Service56
+} from "./credential-pv6wngh8.js";
 import {
   AbsolutePath2
-} from "./config-922hggd3.js";
+} from "./credential-922hggd3.js";
 import {
   Service80
-} from "./config-vyy061a2.js";
+} from "./credential-995e57hq.js";
 import {
-  Service64
-} from "./config-9b1g8vzp.js";
+  Service55
+} from "./credential-9v0v5k0m.js";
 import {
   DirectorySource2,
   UrlSource2,
-  Source3
-} from "./config-ps3c5a77.js";
+  Source4
+} from "./credential-0y2g8rq0.js";
 import {
-  Service5
-} from "./config-3pe7sts8.js";
+  Service8
+} from "./credential-fhs97t90.js";
 import {
   parse2
-} from "./config-0bywbddq.js";
+} from "./credential-r68z10wk.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/config/plugin/skill.ts
 var exports_skill = {};
 __export(exports_skill, {
   ConfigSkillPlugin: () => exports_skill,
-  Plugin: () => Plugin5
+  Plugin: () => Plugin9
 });
 import { define } from "@opencode/plugin/effect/plugin";
 import { FSUtil } from "@opencode/util/fs-util";
 import { Global } from "@opencode/util/global";
 import path from "path";
 import { Effect, FiberMap, PubSub, Semaphore, Stream } from "effect";
-var Plugin5 = define({
+var Plugin9 = define({
   id: "opencode.config.skill",
   effect: Effect.fn(function* (ctx) {
-    const config = yield* Service64;
-    const discovery = yield* Service5;
+    const config = yield* Service55;
+    const discovery = yield* Service8;
     const fs = yield* FSUtil.Service;
     const global = yield* Global.Service;
     const location = yield* Service80;
-    const watcher = yield* Service65;
+    const watcher = yield* Service56;
     const loaded = {
       entries: yield* config.entries(),
       skills: []
@@ -87,7 +87,7 @@ var Plugin5 = define({
     const sources = () => {
       const result = [];
       const add = (source) => {
-        if (result.some((item) => Source3.equals(item, source)))
+        if (result.some((item) => Source4.equals(item, source)))
           return;
         result.push(source);
       };
@@ -112,7 +112,7 @@ var Plugin5 = define({
     };
     const load = Effect.fn("ConfigSkillPlugin.load")(function* (source) {
       const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load skill source", {
-        source: Source3.key(source),
+        source: Source4.key(source),
         cause
       }).pipe(Effect.as([]))));
       const roots = (yield* Effect.forEach(directories, watchDirectory)).flat();
@@ -141,7 +141,7 @@ var Plugin5 = define({
         }
       }
       yield* Effect.logDebug("skill source loaded", {
-        source: Source3.key(source),
+        source: Source4.key(source),
         type: source.type,
         directories,
         skills: skills.map((skill) => skill.id)
@@ -160,7 +160,7 @@ var Plugin5 = define({
       if (file) {
         yield* Effect.logInfo("skills rescanned", {
           file,
-          sources: current.map(Source3.key),
+          sources: current.map(Source4.key),
           skills: loaded.skills.map((skill) => skill.id)
         });
       }
@@ -176,4 +176,4 @@ var Plugin5 = define({
   })
 });
 
-export { Plugin5, exports_skill };
+export { Plugin9, exports_skill };

package/dist/chunks/{config-x1ezjp6w.js → credential-x1ezjp6w.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/session/subagent-completion.ts
 var exports_subagent_completion = {};

package/dist/chunks/{config-2zzff5mh.js → credential-x5fprgp4.js}

@@ -1,15 +1,15 @@
 import {
   BlockedError2
-} from "./config-vgpkvtp0.js";
+} from "./credential-eyj09mx0.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/plugin/plan.ts
 var exports_plan = {};
 __export(exports_plan, {
   PlanPlugin: () => exports_plan,
-  Plugin: () => Plugin27
+  Plugin: () => Plugin28
 });
 import { Message, ToolFailure } from "@opencode/ai";
 import { define } from "@opencode/plugin/effect/plugin";
@@ -29,7 +29,7 @@ You remain in Plan mode until the user switches agents. If the user asks you to
 var leave = `<system-reminder>
 You are NO LONGER in Plan mode. The previous Plan restrictions no longer apply. Any Plan mode instructions from earlier in this conversation are no longer active.
 </system-reminder>`;
-var Plugin27 = define({
+var Plugin28 = define({
   id: "opencode.plan",
   effect: Effect.fn(function* (ctx) {
     const global = yield* Global.Service;
@@ -106,4 +106,4 @@ function lastReminder(messages, enterReminder) {
   }, undefined);
 }
 
-export { Plugin27, exports_plan };
+export { Plugin28, exports_plan };

package/dist/chunks/{config-dmqcgk4z.js → credential-xkntkrq7.js}

@@ -1,15 +1,15 @@
 import {
   SessionMessage2
-} from "./config-gftt206x.js";
+} from "./credential-gftt206x.js";
 import {
   __export
-} from "./config-9rqn6x4v.js";
+} from "./credential-9rqn6x4v.js";
 
 // src/session/message-updater.ts
 var exports_message_updater = {};
 __export(exports_message_updater, {
   SessionMessageUpdater: () => exports_message_updater,
-  update: () => update3
+  update: () => update2
 });
 import { castDraft, produce } from "immer";
 import { DateTime, Effect, Match, pipe, Schema } from "effect";
@@ -21,7 +21,7 @@ var projectTerminalSnapshot = (draft, event) => {
       files: event.data.files ? Array.from(event.data.files) : undefined
     };
 };
-function update3(adapter, event) {
+function update2(adapter, event) {
   const created = DateTime.makeUnsafe(event.created);
   const latestTool = (assistant, id) => assistant.content.findLast((item) => item.type === "tool" && item.id === id);
   const latestText = (assistant) => assistant.content.findLast((item) => item.type === "text");
@@ -402,4 +402,4 @@ function update3(adapter, event) {
   return project(event);
 }
 
-export { update3, exports_message_updater };
+export { update2, exports_message_updater };