@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-8qnjnss5.js

@@ -0,0 +1,74 @@
+import {
+  Service80
+} from "./worktree-ecj1wrg9.js";
+import {
+  Service35
+} from "./worktree-vkez6a4k.js";
+import {
+  awaitActivation2
+} from "./worktree-1x11rq2a.js";
+import {
+  provenance2
+} from "./worktree-w1k39n5e.js";
+import {
+  preview2
+} from "./worktree-wpdyyhk3.js";
+import {
+  baseTranscript2
+} from "./worktree-tm64n74p.js";
+import {
+  Service19
+} from "./worktree-0k40b2vq.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/generate.ts
+var exports_generate = {};
+__export(exports_generate, {
+  SessionGenerate: () => exports_generate,
+  generate: () => generate3
+});
+import { LLMClient, Message } from "@opencode/ai";
+import { Effect } from "effect";
+var generate3 = Effect.fn("SessionGenerate.generate")(function* (input) {
+  const instances = yield* Service35;
+  const database = yield* Service80;
+  const llm = yield* LLMClient.Service;
+  return yield* Effect.gen(function* () {
+    yield* awaitActivation2;
+    const context = yield* Service19;
+    const selection = yield* context.select(input.session.id);
+    const model = yield* context.resolveModel(selection.session);
+    const history = yield* preview2(database.db, selection.session.id, selection.instructions, provenance2(model) ?? "local");
+    const transcript = baseTranscript2({
+      agent: selection.agent.info,
+      model,
+      tools: selection.tools,
+      initial: history.initial,
+      messages: history.messages
+    });
+    const prepared = yield* context.prepare({
+      kind: "generate",
+      scope: { session: selection.session, agentID: selection.agent.id, model, tools: selection.tools },
+      transcript: {
+        system: transcript.system,
+        messages: [
+          ...transcript.messages,
+          ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+          Message.user(input.prompt)
+        ]
+      }
+    });
+    yield* Effect.logInfo("sending session generation request", {
+      sessionID: selection.session.id,
+      providerID: model.ref.providerID,
+      modelID: model.ref.id
+    });
+    const response = yield* llm.generate(prepared.request, prepared.options);
+    yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+    return response.text;
+  }).pipe(instances.provide(input.session));
+});
+
+export { generate3, exports_generate };

package/dist/chunks/worktree-8t34d1ka.js

@@ -0,0 +1,201 @@
+import {
+  useragent2
+} from "./worktree-xrd4famk.js";
+import {
+  OAuth3,
+  Service66
+} from "./worktree-0tg2xvbt.js";
+import {
+  ID8,
+  MethodID2
+} from "./worktree-g0he3e83.js";
+import {
+  ID12
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/xai.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Effect, Option, Schema } from "effect";
+var clientID = "b1a00492-073a-47ea-816f-4c329264a828";
+var issuer = "https://auth.x.ai/oauth2";
+var deviceGrant = "urn:ietf:params:oauth:grant-type:device_code";
+var scope = "openid profile email offline_access grok-cli:access api:access";
+var pollingSafetyMargin = 3000;
+var browserMethodID = MethodID2.make("browser");
+var deviceMethodID = MethodID2.make("device");
+var providerID = ID12.make("xai");
+var Token = Schema.Struct({
+  access_token: Schema.String,
+  refresh_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number)
+});
+var Device = Schema.Struct({
+  device_code: Schema.String,
+  user_code: Schema.String,
+  verification_uri: Schema.String,
+  verification_uri_complete: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number),
+  interval: Schema.optional(Schema.Number)
+});
+var DeviceError = Schema.Struct({
+  error: Schema.optional(Schema.String),
+  error_description: Schema.optional(Schema.String)
+});
+var decodeDeviceError = Schema.decodeUnknownOption(Schema.fromJsonString(DeviceError));
+var device = (app) => ({
+  integrationID: ID8.make("xai"),
+  method: {
+    id: deviceMethodID,
+    type: "oauth",
+    label: "SuperGrok Subscription"
+  },
+  authorize: () => request(`${issuer}/device/code`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({ client_id: clientID, scope, referrer: "opencode" }).toString()
+  }, Device).pipe(Effect.flatMap((value) => Clock.currentTimeMillis.pipe(Effect.map((created) => {
+    const lifetime = positiveSeconds(value.expires_in, 0);
+    return {
+      mode: "auto",
+      url: value.verification_uri_complete ?? value.verification_uri,
+      instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
+      ...lifetime ? { expiresAt: created + lifetime * 1000 } : {},
+      callback: poll(value, app).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens)))
+    };
+  })))),
+  refresh: (value) => refresh(deviceMethodID, OAuth3.make({ ...value, methodID: deviceMethodID }), app)
+});
+var XAIPlugin2 = define({
+  id: "opencode.provider.xai",
+  effect: Effect.fn(function* (ctx) {
+    const credentials = yield* Service66;
+    yield* Effect.forEach(yield* credentials.list(ID8.make("xai")), (credential) => {
+      if (credential.value.type !== "oauth" || credential.value.methodID !== browserMethodID)
+        return Effect.void;
+      return credentials.update(credential.id, {
+        value: OAuth3.make({ ...credential.value, methodID: deviceMethodID })
+      });
+    }, { discard: true });
+    yield* ctx.integration.transform((editor) => {
+      editor.update("xai", (integration) => {
+        integration.name = "xAI";
+      });
+      editor.method.update(device(ctx.app));
+      editor.method.update({ integrationID: "xai", method: { type: "key", label: "Manually enter API Key" } });
+    });
+    yield* ctx.catalog.transform((catalog) => {
+      const provider = catalog.provider.get(providerID);
+      if (!provider)
+        return;
+      for (const model of provider.models.values()) {
+        catalog.model.update(providerID, model.id, (draft) => {
+          draft.capabilities.responsesWebsockets = true;
+        });
+      }
+    });
+  })
+});
+function refresh(methodID, value, app) {
+  return request(`${issuer}/token`, {
+    method: "POST",
+    headers: headers(app),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: value.refresh,
+      client_id: clientID
+    }).toString()
+  }, Token).pipe(Effect.flatMap((tokens) => credential(methodID, tokens, value.refresh, value.metadata)));
+}
+function poll(device, app) {
+  return Effect.gen(function* () {
+    const started = yield* Clock.currentTimeMillis;
+    const expires = started + positiveSeconds(device.expires_in, 300) * 1000;
+    const loop = (interval) => Effect.gen(function* () {
+      if ((yield* Clock.currentTimeMillis) >= expires) {
+        return yield* Effect.fail(new Error("xAI device authorization timed out"));
+      }
+      const response = yield* send(`${issuer}/token`, {
+        method: "POST",
+        headers: headers(app),
+        body: new URLSearchParams({
+          grant_type: deviceGrant,
+          client_id: clientID,
+          device_code: device.device_code
+        }).toString()
+      });
+      if (response.ok)
+        return yield* decode(response, Token);
+      const error = yield* Effect.promise(() => response.text()).pipe(Effect.map((body) => Option.getOrUndefined(decodeDeviceError(body))), Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (error?.error === "authorization_pending") {
+        return yield* Effect.sleep(interval + pollingSafetyMargin).pipe(Effect.andThen(loop(interval)));
+      }
+      if (error?.error === "slow_down") {
+        const next = interval + 5000;
+        return yield* Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(loop(next)));
+      }
+      if (error?.error === "access_denied" || error?.error === "authorization_denied") {
+        return yield* Effect.fail(new Error("xAI device authorization was denied"));
+      }
+      if (error?.error === "expired_token") {
+        return yield* Effect.fail(new Error("xAI device code expired - please re-run login"));
+      }
+      const detail = error?.error_description ?? error?.error;
+      return yield* Effect.fail(new Error(`xAI device token exchange failed (${response.status})${detail ? `: ${detail}` : ""}`));
+    });
+    return yield* loop(Math.max(positiveSeconds(device.interval, 5) * 1000, 1000));
+  });
+}
+function request(url, init, schema) {
+  return send(url, init).pipe(Effect.flatMap((response) => {
+    if (response.ok)
+      return decode(response, schema);
+    return Effect.promise(() => response.text()).pipe(Effect.flatMap((detail) => Effect.fail(new Error(`xAI request failed (${response.status})${detail ? `: ${detail}` : ""}`))));
+  }));
+}
+function send(url, init) {
+  return Effect.tryPromise({
+    try: (signal) => fetch(url, { ...init, signal }),
+    catch: (cause) => cause
+  });
+}
+function decode(response, schema) {
+  return Effect.promise(() => response.json()).pipe(Effect.map(Schema.decodeUnknownSync(schema)));
+}
+function credential(methodID, tokens, currentRefresh, metadata) {
+  const refresh = tokens.refresh_token ?? currentRefresh;
+  if (!refresh)
+    return Effect.fail(new Error("xAI token response is missing refresh_token"));
+  return Effect.succeed(OAuth3.make({
+    type: "oauth",
+    methodID,
+    refresh,
+    access: tokens.access_token,
+    expires: tokenExpiration(tokens),
+    metadata
+  }));
+}
+function tokenExpiration(tokens) {
+  if (tokens.expires_in)
+    return Date.now() + positiveSeconds(tokens.expires_in, 3600) * 1000;
+  const payload = tokens.access_token.split(".")[1];
+  if (!payload)
+    return Date.now() + 3600 * 1000;
+  const claims = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ exp: Schema.optional(Schema.Number) })))(Buffer.from(payload, "base64url").toString());
+  const expiration = Option.getOrUndefined(claims)?.exp;
+  return expiration ? expiration * 1000 : Date.now() + 3600 * 1000;
+}
+function headers(app) {
+  return {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json",
+    "User-Agent": useragent2(app)
+  };
+}
+function positiveSeconds(value, fallback) {
+  const seconds = Number(value);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : fallback;
+}
+
+export { XAIPlugin2 };

package/dist/chunks/worktree-922hggd3.js

@@ -0,0 +1,21 @@
+// src/schema.ts
+import { Schema } from "effect";
+import {
+  AbsolutePath as AbsolutePath2,
+  DateTimeUtcFromMillis as DateTimeUtcFromMillis2,
+  NonNegativeInt as NonNegativeInt2,
+  optional as optional2,
+  PositiveInt as PositiveInt2,
+  RelativePath as RelativePath2,
+  statics as statics2
+} from "@opencode/schema/schema";
+function Newtype2() {
+  return (tag, schema) => {
+    class Base {
+    }
+    Object.setPrototypeOf(Base, schema.pipe(Schema.brand(tag)));
+    return Base;
+  };
+}
+
+export { AbsolutePath2, DateTimeUtcFromMillis2, NonNegativeInt2, optional2, PositiveInt2, RelativePath2, statics2, Newtype2 };

package/dist/chunks/worktree-923hzxn9.js

@@ -0,0 +1,49 @@
+import {
+  Service54
+} from "./worktree-r82b328h.js";
+import {
+  Service26
+} from "./worktree-146a62k1.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/config/plugin/mcp.ts
+var exports_mcp = {};
+__export(exports_mcp, {
+  ConfigMcpPlugin: () => exports_mcp,
+  Plugin: () => Plugin31,
+  register: () => register2
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin31 = define({
+  id: "opencode.config.mcp",
+  effect: Effect.fn(function* (ctx) {
+    yield* register2(ctx.event.subscribe());
+  })
+});
+var register2 = Effect.fn("ConfigMCPPlugin.register")(function* (events) {
+  const config = yield* Service54;
+  const mcp = yield* Service26;
+  const loaded = { entries: [] };
+  yield* events.pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(mcp.reload()), Effect.catchCause((cause) => Effect.logError("failed to reload MCP config", { cause })))), Effect.ignore, Effect.forkScoped({ startImmediately: true }));
+  loaded.entries = yield* config.entries();
+  yield* mcp.transform((editor) => {
+    const documents = loaded.entries.filter((entry) => entry.type === "document");
+    const timeout = Object.assign({}, ...documents.flatMap((entry) => entry.info.mcp?.timeout ? [entry.info.mcp.timeout] : []));
+    const servers = new Map;
+    for (const document of documents) {
+      for (const [name, server] of Object.entries(document.info.mcp?.servers ?? {})) {
+        servers.set(name, server);
+      }
+    }
+    for (const [name, server] of servers) {
+      if (editor.get(name))
+        continue;
+      editor.set(name, { ...server, timeout: { ...timeout, ...server.timeout } });
+    }
+  });
+});
+
+export { Plugin31, register2, exports_mcp };

package/dist/chunks/worktree-97y4vk9t.js

@@ -0,0 +1,228 @@
+import {
+  useragent2
+} from "./worktree-xrd4famk.js";
+import {
+  Service79
+} from "./worktree-vrm5r67w.js";
+import {
+  OAuth3,
+  Event16
+} from "./worktree-0tg2xvbt.js";
+import {
+  ID8,
+  MethodID2
+} from "./worktree-g0he3e83.js";
+import {
+  ID12,
+  isAISDK2,
+  packageName2,
+  mergeOverlay2
+} from "./worktree-9qn3qky1.js";
+import {
+  iife2
+} from "./worktree-1kg9ymc8.js";
+import {
+  which2
+} from "./worktree-qaymkmh1.js";
+import {
+  configuredSettings2
+} from "./worktree-asseqh46.js";
+
+// src/plugin/provider/azure.ts
+import { Clock, Effect, Schema, Semaphore, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+import { AppProcess } from "@opencode/util/process";
+var cognitiveScope = "https://cognitiveservices.azure.com/.default";
+var foundryScope = "https://ai.azure.com/.default";
+var methodID = MethodID2.make("azure-cli");
+var decodeJSON = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+var decodeToken = Schema.decodeUnknownEffect(Schema.Struct({
+  accessToken: Schema.NonEmptyString,
+  expires_on: Schema.optional(Schema.Number),
+  expiresOn: Schema.optional(Schema.NonEmptyString)
+}));
+function selectLanguage(sdk, modelID, useChat) {
+  if (useChat && sdk.chat)
+    return sdk.chat(modelID);
+  if (sdk.responses)
+    return sdk.responses(modelID);
+  if (sdk.messages)
+    return sdk.messages(modelID);
+  if (sdk.chat)
+    return sdk.chat(modelID);
+  return sdk.languageModel(modelID);
+}
+var AzurePlugin2 = define({
+  id: "opencode.provider.azure",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(ID12.azure);
+    const processes = yield* AppProcess.Service;
+    const bus = yield* Service79;
+    const tokens = new Map;
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = {};
+    const command = (args) => processes.run(ChildProcess.make("az", args, { extendEnv: true, stdin: "ignore" }), { timeout: "10 seconds" }).pipe(Effect.flatMap(AppProcess.requireSuccess), Effect.flatMap((result) => decodeJSON(result.stdout.toString("utf8"))));
+    const token = Effect.fn("AzurePlugin.token")(function* (scope) {
+      const now = yield* Clock.currentTimeMillis;
+      const cached = tokens.get(scope);
+      if (cached && cached.expires - now > 5 * 60000)
+        return cached;
+      const result = yield* command(["account", "get-access-token", "--scope", scope, "--output", "json"]).pipe(Effect.flatMap(decodeToken));
+      const expires = result.expires_on !== undefined ? result.expires_on * 1000 : Date.parse(result.expiresOn ?? "");
+      if (!Number.isFinite(expires))
+        return yield* Effect.fail(new Error("Azure CLI returned an invalid token expiration"));
+      const refreshed = { access: result.accessToken, expires };
+      tokens.set(scope, refreshed);
+      return refreshed;
+    });
+    const available = Boolean(which2("az"));
+    const form = () => iife2(() => {
+      if (resolveResourceName(configured) || typeof configured?.baseURL === "string")
+        return;
+      return Form.Fields.make([
+        {
+          type: "string",
+          key: "resourceName",
+          title: "Enter Azure Resource Name",
+          placeholder: "e.g. my-models",
+          required: true
+        }
+      ]);
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: ID12.azure,
+        method: { type: "key", label: "API key", form: form() }
+      });
+      if (!available)
+        return;
+      editor.method.update({
+        integrationID: ID12.azure,
+        method: {
+          id: methodID,
+          type: "oauth",
+          label: "Microsoft Entra ID (Azure CLI)",
+          form: form()
+        },
+        authorize: (answer) => Effect.succeed({
+          mode: "auto",
+          url: "",
+          instructions: "Sign in with `az login` before continuing.",
+          callback: Effect.gen(function* () {
+            const resourceName = typeof answer.resourceName === "string" ? answer.resourceName : resolveResourceName(configured);
+            if (!resourceName)
+              return yield* Effect.fail(new Error("Azure resource name is required"));
+            const current = yield* token(cognitiveScope);
+            loaded.resource = resourceName;
+            yield* ctx.catalog.reload();
+            return OAuth3.make({
+              type: "oauth",
+              methodID,
+              access: current.access,
+              refresh: "azure-cli",
+              expires: current.expires,
+              metadata: { resourceName }
+            });
+          })
+        }),
+        refresh: (credential) => token(cognitiveScope).pipe(Effect.map((current) => OAuth3.make({ ...credential, access: current.access, expires: current.expires })))
+      });
+    });
+    const load = Effect.fn("AzurePlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active(ID12.azure);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID) {
+        loaded.resource = undefined;
+        return;
+      }
+      const resource = typeof credential.metadata?.resourceName === "string" ? credential.metadata.resourceName : undefined;
+      loaded.resource = resource;
+    });
+    yield* load();
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (item.provider.id !== ID12.azure && packageName2(item.provider.package) !== "@ai-sdk/azure")
+          continue;
+        const resourceName = resolveResourceName(item.provider.settings, loaded.resource);
+        if (resourceName)
+          evt.provider.update(item.provider.id, (provider) => {
+            provider.settings = {
+              ...provider.settings,
+              resourceName,
+              ...typeof provider.settings?.baseURL === "string" ? { baseURL: expandResourceName(provider.settings.baseURL, resourceName) } : {}
+            };
+          });
+        for (const model of item.models.values()) {
+          evt.model.update(item.provider.id, model.id, (draft) => {
+            if (resourceName && typeof draft.settings?.baseURL === "string")
+              draft.settings.baseURL = expandResourceName(draft.settings.baseURL, resolveResourceName(draft.settings, resourceName) ?? resourceName);
+            if (responsesWebSocketCapable(item.provider, draft))
+              draft.capabilities.responsesWebsockets = true;
+          });
+        }
+      }
+    });
+    const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event16.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID8.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== ID12.azure)
+        return;
+      const connection = yield* ctx.integration.connection.active(ID12.azure);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID)
+        return;
+      const url = new URL(evt.request.url);
+      const scope = url.hostname.endsWith(".services.ai.azure.com") && !url.pathname.startsWith("/models") ? foundryScope : cognitiveScope;
+      const current = yield* token(scope).pipe(Effect.orDie);
+      evt.request.headers.delete("api-key");
+      evt.request.headers.delete("x-api-key");
+      evt.request.headers.set("authorization", `Bearer ${current.access}`);
+      evt.request.headers.set("user-agent", useragent2(ctx.app));
+    }), { providerID: ID12.azure });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "@ai-sdk/azure")
+        return;
+      if (evt.model.providerID === ID12.azure) {
+        if (!evt.options.resourceName && !evt.options.baseURL && (!isAISDK2(evt.model.package) || typeof evt.model.settings?.baseURL !== "string")) {
+          throw new Error("Azure resource name is missing; set AZURE_RESOURCE_NAME or configure resourceName/baseURL");
+        }
+      }
+      const mod = yield* Effect.promise(() => import("@ai-sdk/azure"));
+      evt.sdk = mod.createAzure(evt.options);
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.azure)
+        return;
+      evt.language = selectLanguage(evt.sdk, evt.model.modelID ?? evt.model.id, Boolean(evt.options.useCompletionUrls));
+    }));
+  })
+});
+function resolveResourceName(settings, fallback) {
+  const configured = settings?.resourceName;
+  if (typeof configured === "string" && configured.trim() !== "")
+    return configured;
+  return fallback ?? process.env.AZURE_RESOURCE_NAME ?? process.env.AZURE_COGNITIVE_SERVICES_RESOURCE_NAME;
+}
+function expandResourceName(baseURL, resourceName) {
+  return baseURL.replaceAll("${AZURE_RESOURCE_NAME}", resourceName).replaceAll("${AZURE_COGNITIVE_SERVICES_RESOURCE_NAME}", resourceName);
+}
+function responsesWebSocketCapable(provider, model) {
+  if (packageName2(model.package ?? provider.package) !== "@ai-sdk/azure")
+    return false;
+  const settings = mergeOverlay2(provider.settings, model.settings);
+  if (settings?.useCompletionUrls === true || settings?.useDeploymentBasedUrls === true)
+    return false;
+  if (settings?.apiVersion !== undefined && settings.apiVersion !== "v1")
+    return false;
+  if (typeof settings?.baseURL !== "string")
+    return true;
+  return /^https:\/\/[^/]+\.openai\.azure\.com(?:\/|$)/i.test(settings.baseURL);
+}
+
+export { AzurePlugin2 };

package/dist/chunks/worktree-9a4afbnw.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260622170816_reset_v2_session_state.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622170816_reset_v2_session_state",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`DELETE FROM \`session_context_epoch\`;`);
+      yield* tx.run(`DELETE FROM \`session_input\`;`);
+      yield* tx.run(`DELETE FROM \`session_message\`;`);
+      yield* tx.run(`DELETE FROM \`event\`;`);
+      yield* tx.run(`DELETE FROM \`event_sequence\`;`);
+    });
+  }
+};
+var _20260622170816_reset_v2_session_state_default = migration;
+
+export { _20260622170816_reset_v2_session_state_default };