@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-a2yyszsy.js

@@ -0,0 +1,75 @@
+import {
+  exports_location
+} from "./permission-1e2ryyac.js";
+import {
+  exports_project
+} from "./permission-j2hktz7g.js";
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/location-mutation.ts
+var exports_location_mutation = {};
+__export(exports_location_mutation, {
+  node: () => node,
+  externalDirectoryPermission: () => externalDirectoryPermission,
+  Service: () => Service,
+  ResolveInput: () => ResolveInput,
+  LocationMutation: () => exports_location_mutation,
+  Kind: () => Kind
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var Kind = Schema.Literals(["file", "directory"]);
+var ResolveInput = Schema.Struct({
+  path: Schema.String,
+  kind: Kind.pipe(Schema.optional)
+});
+var externalDirectoryPermission = (input) => ({
+  action: input.action,
+  resources: [input.resource],
+  save: [input.save]
+});
+
+class Service extends Context.Service()("@opencode/LocationMutation") {
+}
+var slash = (value) => value.replaceAll("\\", "/");
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* exports_location.Service;
+  const resolve = Effect.fn("LocationMutation.resolve")(function* (input) {
+    const absolute = path.resolve(location.directory, input.path);
+    if (FSUtil.contains(location.directory, absolute)) {
+      return {
+        absolute,
+        resource: slash(path.relative(location.directory, absolute) || ".")
+      };
+    }
+    const type = input.kind === "directory" ? "Directory" : (yield* fs.stat(absolute).pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined))))?.type;
+    const externalDirectory = type === "Directory" ? absolute : path.dirname(absolute);
+    const externalResource = slash(path.join(externalDirectory, "*"));
+    return {
+      absolute,
+      resource: slash(absolute),
+      externalDirectory: {
+        action: "external_directory",
+        directory: externalDirectory,
+        resource: externalResource,
+        save: slash(path.join((yield* exports_project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"))
+      }
+    };
+  });
+  return Service.of({ resolve });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer: layer.pipe(Layer.orDie),
+  deps: [FSUtil.node, exports_location.node]
+});
+
+export { Kind, ResolveInput, externalDirectoryPermission, Service, node, exports_location_mutation };

package/dist/chunks/permission-a3xgesk5.js

@@ -0,0 +1,174 @@
+import {
+  lazy
+} from "./permission-8w9tzfz1.js";
+import {
+  load
+} from "./permission-6jdj5f9n.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/filesystem/watcher.ts
+var exports_watcher = {};
+__export(exports_watcher, {
+  testLayer: () => testLayer,
+  node: () => node,
+  nativeNode: () => nativeNode,
+  nativeLayer: () => nativeLayer,
+  layer: () => layer,
+  hasNativeBinding: () => hasNativeBinding,
+  configured: () => configured,
+  Watcher: () => exports_watcher,
+  Test: () => Test,
+  Service: () => Service,
+  Options: () => Options,
+  Native: () => Native,
+  Event: () => Event
+});
+import { createWrapper } from "@parcel/watcher/wrapper";
+import { FileSystem } from "@opencode-ai/schema/filesystem";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect";
+import { watch as watchFileSystem } from "node:fs";
+import path from "path";
+var SUBSCRIBE_TIMEOUT_MS = 1e4;
+var Event = { Updated: FileSystem.Event.Changed };
+var watcher = lazy(() => {
+  try {
+    return createWrapper(load());
+  } catch {
+    return;
+  }
+});
+function getBackend() {
+  if (process.platform === "win32")
+    return "windows";
+  if (process.platform === "darwin")
+    return "fs-events";
+  if (process.platform === "linux")
+    return "inotify";
+}
+var hasNativeBinding = () => !!watcher();
+
+class Native extends Context.Service()("@opencode/Watcher/Native") {
+}
+var Options = Schema.Struct({
+  enabled: Schema.optional(Schema.Boolean)
+});
+
+class Service extends Context.Service()("@opencode/Watcher") {
+}
+
+class Test extends Context.Service()("@opencode/Watcher/Test") {
+}
+var layer = (options) => Layer.effect(Service, Effect.gen(function* () {
+  if (options?.enabled === false) {
+    return Service.of({ subscribe: () => Effect.succeed(Stream.empty) });
+  }
+  const native = yield* Native;
+  const watchers = yield* RcMap.make({
+    lookup: (key) => Effect.gen(function* () {
+      const pubsub = yield* Effect.acquireRelease(PubSub.unbounded(), (pubsub2) => PubSub.shutdown(pubsub2));
+      const subscription = yield* Effect.acquireRelease(native.subscribe({
+        type: key.type,
+        target: key.target,
+        ignore: key.ignore,
+        publish: (update) => PubSub.publishUnsafe(pubsub, update)
+      }), (subscription2) => subscription2 ? Effect.promise(() => subscription2.unsubscribe()).pipe(Effect.ignoreCause, Effect.andThen(Effect.logInfo("watcher stopped", { path: key.target, type: key.type }))) : Effect.void, { interruptible: true });
+      if (!subscription) {
+        yield* PubSub.shutdown(pubsub);
+        return pubsub;
+      }
+      yield* Effect.logInfo("watcher started", {
+        path: key.target,
+        type: key.type,
+        backend: subscription.backend,
+        ignores: key.ignore.length
+      });
+      return pubsub;
+    })
+  });
+  const subscribe = (input) => {
+    const target = path.resolve(input.path);
+    const ignore = [...new Set(input.type === "directory" ? input.ignore ?? [] : [])].toSorted();
+    return Effect.gen(function* () {
+      yield* Effect.logInfo("watcher subscribe", {
+        path: target,
+        type: input.type,
+        ignores: ignore.length
+      });
+      return Stream.unwrap(Effect.gen(function* () {
+        const pubsub = yield* RcMap.get(watchers, { type: input.type, target, ignore });
+        return Stream.fromPubSub(pubsub);
+      }));
+    });
+  };
+  return Service.of({ subscribe });
+}));
+var testLayer = Layer.effectContext(Effect.gen(function* () {
+  const subscriptions = [];
+  const active = new Set;
+  const native = Native.of({
+    subscribe: (input) => Effect.sync(() => {
+      subscriptions.push(input.type === "file" ? { path: input.target, type: "file" } : input.ignore.length > 0 ? { path: input.target, type: "directory", ignore: input.ignore } : { path: input.target, type: "directory" });
+      active.add(input.publish);
+      return {
+        unsubscribe: () => {
+          active.delete(input.publish);
+          return Promise.resolve();
+        }
+      };
+    })
+  });
+  const context = yield* Layer.build(layer().pipe(Layer.provide(Layer.succeed(Native, native))));
+  const test = Test.of({
+    subscribe: Context.get(context, Service).subscribe,
+    emit: (update) => Effect.sync(() => active.forEach((publish) => publish(update))),
+    subscriptions: () => Effect.sync(() => [...subscriptions])
+  });
+  return Context.empty().pipe(Context.add(Service, test), Context.add(Test, test));
+}));
+var nativeLayer = Layer.succeed(Native, Native.of({
+  subscribe: (input) => {
+    if (input.type === "file") {
+      return Effect.sync(() => {
+        const directory = path.dirname(input.target);
+        const subscription = watchFileSystem(directory, { recursive: false }, (_event, file) => {
+          if (file && path.resolve(directory, file.toString()) !== input.target)
+            return;
+          input.publish({ path: input.target, type: "update" });
+        });
+        if ("on" in subscription && typeof subscription.on === "function") {
+          subscription.on("error", (error) => Effect.runFork(Effect.logError("watcher callback failed", { path: input.target, error })));
+        }
+        return { unsubscribe: () => Promise.resolve(subscription.close()), backend: "node" };
+      });
+    }
+    return subscribeDirectory(watcher(), getBackend(), input.target, input.ignore, input.publish);
+  }
+}));
+var nativeNode = makeGlobalNode({ service: Native, layer: nativeLayer, deps: [] });
+function configured(options) {
+  return makeGlobalNode({ service: Service, layer: layer(options), deps: [nativeNode] });
+}
+var node = configured();
+function subscribeDirectory(native, backend, directory, ignore, publish) {
+  if (!native || !backend) {
+    return Effect.logError("watcher backend not supported", { directory, platform: process.platform }).pipe(Effect.as(undefined));
+  }
+  const callback = (error, updates) => {
+    if (error)
+      Effect.runFork(Effect.logError("watcher callback failed", { error }));
+    for (const update of updates)
+      publish(update);
+  };
+  const pending = native.subscribe(directory, callback, { ignore: [...ignore], backend });
+  return Effect.promise(() => pending).pipe(Effect.map((subscription) => ({ unsubscribe: () => subscription.unsubscribe(), backend })), Effect.onInterrupt(() => Effect.sync(() => {
+    pending.then((subscription) => subscription.unsubscribe()).catch(() => {});
+  })), Effect.timeout(SUBSCRIBE_TIMEOUT_MS), Effect.catchCause((cause) => Effect.logError("failed to subscribe", {
+    directory,
+    cause: Cause.pretty(cause)
+  }).pipe(Effect.as(undefined))));
+}
+
+export { Event, hasNativeBinding, Native, Options, Service, Test, layer, testLayer, nativeLayer, nativeNode, configured, node, exports_watcher };

package/dist/chunks/permission-a65h300v.js

@@ -0,0 +1,155 @@
+import {
+  AbsolutePath
+} from "./permission-j07kk359.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/skill/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  node: () => node,
+  SkillDiscovery: () => exports_discovery,
+  Service: () => Service
+});
+import path from "path";
+import { Context, Effect, Layer, Schedule, Schema } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { httpClient } from "@opencode-ai/util/effect/app-node-platform";
+import { Hash } from "@opencode-ai/util/hash";
+var skillConcurrency = 4;
+var fileConcurrency = 8;
+function isSafeSegment(value) {
+  return value.length > 0 && value !== "." && value !== ".." && !value.includes("/") && !value.includes("\\") && !value.includes("\x00");
+}
+function isSafeRelativePath(value) {
+  const segments = value.split("/");
+  return value.length > 0 && !value.includes("\\") && !value.includes("\x00") && !value.includes("?") && !value.includes("#") && !URL.canParse(value) && !path.posix.isAbsolute(value) && !path.win32.isAbsolute(value) && segments.every((segment) => {
+    try {
+      const decoded = decodeURIComponent(segment);
+      return decoded.length > 0 && decoded !== "." && decoded !== ".." && !decoded.includes("/") && !decoded.includes("\\") && !decoded.includes("\x00");
+    } catch {
+      return false;
+    }
+  });
+}
+
+class IndexSkill extends Schema.Class("SkillDiscovery.IndexSkill")({
+  name: Schema.String,
+  version: Schema.optional(Schema.String),
+  files: Schema.Array(Schema.String)
+}) {
+}
+
+class Index extends Schema.Class("SkillDiscovery.Index")({
+  skills: Schema.Array(IndexSkill)
+}) {
+}
+
+class Service extends Context.Service()("@opencode/SkillDiscovery") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const global = yield* Global.Service;
+  const http = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+    retryOn: "errors-and-responses",
+    times: 2,
+    schedule: Schedule.exponential(200).pipe(Schedule.jittered)
+  }), HttpClient.filterStatusOk);
+  const download = Effect.fn("SkillDiscovery.download")(function* (url, destination) {
+    if (yield* fs.exists(destination).pipe(Effect.orDie))
+      return true;
+    return yield* HttpClientRequest.get(url).pipe(http.execute, Effect.flatMap((response) => response.arrayBuffer), Effect.flatMap((body) => fs.writeWithDirs(destination, new Uint8Array(body))), Effect.as(true), Effect.catch((error) => Effect.logError("failed to download skill file", { url, error }).pipe(Effect.as(false))));
+  });
+  return Service.of({
+    pull: Effect.fn("SkillDiscovery.pull")(function* (url) {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      const source = new URL(base);
+      const index = new URL("index.json", source).href;
+      const data = yield* HttpClientRequest.get(index).pipe(HttpClientRequest.acceptJson, http.execute, Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)), Effect.catch((error) => Effect.logError("failed to fetch skill index", { url: index, error }).pipe(Effect.as(undefined))));
+      if (!data)
+        return [];
+      const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base));
+      return yield* Effect.forEach(data.skills.flatMap((skill) => {
+        if (!isSafeSegment(skill.name)) {
+          return [];
+        }
+        if (!skill.files.includes("SKILL.md") && !skill.files.includes(`${skill.name}.md`)) {
+          return [];
+        }
+        const root = path.resolve(sourceRoot, skill.name);
+        if (!FSUtil.contains(sourceRoot, root) || root === sourceRoot) {
+          return [];
+        }
+        const skillUrl = new URL(`${encodeURIComponent(skill.name)}/`, source);
+        const versionFile = path.join(root, ".opencode-version");
+        const files = skill.files.map((file) => {
+          if (!isSafeRelativePath(file))
+            return;
+          let resource;
+          try {
+            resource = new URL(file, skillUrl);
+          } catch {
+            return;
+          }
+          if (resource.origin !== source.origin)
+            return;
+          const destination = path.resolve(root, file);
+          if (!FSUtil.contains(root, destination) || destination === root)
+            return;
+          return {
+            url: resource.href,
+            destination,
+            file
+          };
+        });
+        if (files.some((file) => file === undefined)) {
+          return [];
+        }
+        return [{ skill, root, versionFile, files }];
+      }), ({ skill, root, versionFile, files }) => Effect.gen(function* () {
+        const version = skill.version;
+        const current = version === undefined ? undefined : yield* fs.readFileStringSafe(versionFile).pipe(Effect.catch(() => Effect.succeed(undefined)));
+        if (version === undefined || current === version) {
+          yield* Effect.forEach(files, (file) => download(file.url, file.destination), {
+            concurrency: fileConcurrency,
+            discard: true
+          });
+        } else {
+          const token = crypto.randomUUID();
+          const staging = `${root}.tmp-${token}`;
+          const backup = `${root}.old-${token}`;
+          yield* Effect.gen(function* () {
+            const downloaded = yield* Effect.forEach(files, (file) => download(file.url, path.resolve(staging, file.file)), { concurrency: fileConcurrency });
+            if (!downloaded.every(Boolean))
+              return;
+            const exists2 = (yield* fs.exists(path.join(staging, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(staging, `${skill.name}.md`)).pipe(Effect.orDie));
+            if (!exists2)
+              return;
+            yield* fs.writeFileString(path.join(staging, ".opencode-version"), version);
+            yield* Effect.uninterruptible(Effect.gen(function* () {
+              const cached = yield* fs.exists(root).pipe(Effect.orDie);
+              if (cached)
+                yield* fs.rename(root, backup);
+              yield* fs.rename(staging, root).pipe(Effect.catch((error) => Effect.gen(function* () {
+                if (cached)
+                  yield* fs.rename(backup, root).pipe(Effect.ignore);
+                return yield* Effect.fail(error);
+              })));
+              if (cached)
+                yield* fs.remove(backup, { recursive: true, force: true }).pipe(Effect.ignore);
+            }));
+          }).pipe(Effect.catch((error) => Effect.logError("failed to refresh skill", { skill: skill.name, error })), Effect.ensuring(fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
+        }
+        const exists = (yield* fs.exists(path.join(root, "SKILL.md")).pipe(Effect.orDie)) || (yield* fs.exists(path.join(root, `${skill.name}.md`)).pipe(Effect.orDie));
+        return exists ? [AbsolutePath.make(root)] : [];
+      }), { concurrency: skillConcurrency }).pipe(Effect.map((directories) => directories.flat()));
+    })
+  });
+}));
+var node = makeGlobalNode({ service: Service, layer, deps: [httpClient, FSUtil.node, Global.node] });
+
+export { Service, node, exports_discovery };

package/dist/chunks/permission-a6ndeaxw.js

@@ -0,0 +1,162 @@
+import {
+  exports_usage
+} from "./permission-8ywqk2j9.js";
+import {
+  exports_model_headers
+} from "./permission-1xksxgzs.js";
+import {
+  exports_model_http
+} from "./permission-93qdgxxd.js";
+import {
+  llmClient
+} from "./permission-m01ryvbe.js";
+import {
+  exports_model
+} from "./permission-14dbm5wf.js";
+import {
+  exports_hooks
+} from "./permission-t2j2ttmx.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_store
+} from "./permission-2zyawa45.js";
+import {
+  exports_history
+} from "./permission-0cm1xtm8.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_agent
+} from "./permission-0c101nc9.js";
+import {
+  exports_bus
+} from "./permission-r5ce0emk.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/title.ts
+var exports_title = {};
+__export(exports_title, {
+  node: () => node,
+  layer: () => layer,
+  SessionTitle: () => exports_title,
+  Service: () => Service
+});
+import { LLM, LLMClient, LLMEvent, Message } from "@opencode-ai/ai";
+import { Context, DateTime, Effect, Layer, Stream } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { isExactRootFallback } from "@opencode-ai/util/session-title-fallback";
+var MAX_LENGTH = 100;
+var titleChanged = Symbol("Session title changed");
+
+class Service extends Context.Service()("@opencode/SessionTitle") {
+}
+var truncate = (value) => value.length <= MAX_LENGTH ? value : `${value.slice(0, MAX_LENGTH - 3)}...`;
+var isUntitled = (session) => isExactRootFallback({
+  title: session.title,
+  time: { created: DateTime.toEpochMillis(session.time.created) }
+});
+var make = (dependencies) => {
+  const generateForFirstPrompt = Effect.fn("SessionTitle.generateForFirstPrompt")(function* (db, sessionID) {
+    const session = yield* dependencies.store.get(sessionID);
+    if (!session)
+      return;
+    if (session.parentID)
+      return;
+    if (!isUntitled(session))
+      return;
+    const firstUser = yield* exports_history.firstUserMessage(db, session.id);
+    if (!firstUser)
+      return;
+    const agent = yield* dependencies.agents.get(exports_agent.ID.make("title"));
+    if (!agent)
+      return;
+    const resolved = yield* (agent.model ? dependencies.models.resolve({ ...session, model: agent.model }) : dependencies.models.resolve(session)).pipe(Effect.catch(() => Effect.succeed(undefined)));
+    if (!resolved)
+      return;
+    const chunks = [];
+    let failed = false;
+    let usage;
+    const recordUsage = Effect.suspend(() => usage ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
+      sessionID: session.id,
+      source: "title",
+      ...usage
+    }) : Effect.void);
+    const streamed = yield* dependencies.llm.stream(LLM.request({
+      model: resolved.model,
+      http: { headers: exports_model_headers.make(session, dependencies.app) },
+      system: agent.system,
+      messages: [Message.user(firstUser.text)],
+      tools: []
+    }), {
+      http: exports_model_http.middleware(dependencies.hooks, {
+        sessionID: session.id,
+        agent: agent.id,
+        model: resolved.ref
+      })
+    }).pipe(Stream.runForEach((event) => {
+      if (LLMEvent.is.providerError(event))
+        failed = true;
+      if (LLMEvent.is.textDelta(event))
+        chunks.push(event.text);
+      if (LLMEvent.is.stepFinish(event)) {
+        const step = exports_usage.record(event.usage, resolved.cost);
+        usage = usage ? exports_usage.add(usage, step) : step;
+      }
+      return Effect.void;
+    }), Effect.as(true), Effect.catchTag("AI.Error", () => Effect.succeed(false)), Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)));
+    yield* recordUsage;
+    if (!streamed || failed)
+      return;
+    const title = chunks.join("").split(`
+`).map((line) => line.trim()).find((line) => line.length > 0);
+    if (!title)
+      return;
+    const expectedSequence = (yield* exports_bus.latestSequence(db, sessionID)) + 1;
+    const current = yield* dependencies.store.get(sessionID);
+    if (!current || !isUntitled(current))
+      return;
+    yield* dependencies.bus.publish(SessionEvent.Renamed, {
+      sessionID: session.id,
+      title: truncate(title)
+    }, { commit: (sequence) => sequence === expectedSequence ? Effect.void : Effect.die(titleChanged) }).pipe(Effect.catchDefect((defect) => defect === titleChanged ? Effect.void : Effect.die(defect)));
+  });
+  return { generateForFirstPrompt };
+};
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const llm = yield* LLMClient.Service;
+  const agents = yield* exports_agent.Service;
+  const models = yield* exports_model.Service;
+  const store = yield* exports_store.Service;
+  const database = yield* exports_database.Service;
+  const app = yield* exports_app.Metadata;
+  const hooks = yield* exports_hooks.Service;
+  const title = make({ bus, llm, agents, models, store, app, hooks });
+  return Service.of({
+    generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID)
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [
+    exports_bus.node,
+    llmClient,
+    exports_agent.node,
+    exports_model.node,
+    exports_store.node,
+    exports_database.node,
+    exports_app.node,
+    exports_hooks.node
+  ]
+});
+
+export { Service, layer, node, exports_title };

package/dist/chunks/permission-a7aazggv.js

@@ -0,0 +1,110 @@
+import {
+  base_default
+} from "./permission-8m0qaa0v.js";
+import {
+  toLLMMessages
+} from "./permission-6jtjggv5.js";
+import {
+  exports_prompt_cache_key
+} from "./permission-52jzav25.js";
+import {
+  exports_context
+} from "./permission-n59ptmzm.js";
+import {
+  exports_model_headers
+} from "./permission-1xksxgzs.js";
+import {
+  llmClient
+} from "./permission-m01ryvbe.js";
+import {
+  exports_generate
+} from "./permission-xgv25zxy.js";
+import {
+  exports_model
+} from "./permission-14dbm5wf.js";
+import {
+  exports_hooks
+} from "./permission-t2j2ttmx.js";
+import {
+  exports_app
+} from "./permission-50jxp3hw.js";
+import {
+  exports_history
+} from "./permission-0cm1xtm8.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/generate-node.ts
+var exports_generate_node = {};
+__export(exports_generate_node, {
+  node: () => node,
+  layer: () => layer,
+  SessionGenerateNode: () => exports_generate_node
+});
+import { LLM, LLMClient, Message, SystemPart } from "@opencode-ai/ai";
+import { Effect, Layer } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var layer = Layer.effect(exports_generate.Service, Effect.gen(function* () {
+  const context = yield* exports_context.Service;
+  const database = yield* exports_database.Service;
+  const hooks = yield* exports_hooks.Service;
+  const llm = yield* LLMClient.Service;
+  const models = yield* exports_model.Service;
+  const app = yield* exports_app.Metadata;
+  return exports_generate.Service.of({
+    generate: Effect.fn("SessionGenerate.generate")(function* (input) {
+      const selection = yield* context.select(input.sessionID);
+      const model = yield* models.resolve(selection.session);
+      const history = yield* exports_history.preview(database.db, selection.session.id, selection.instructions);
+      const providerMetadataKey = model.model.route.providerMetadataKey ?? model.model.provider;
+      const tools = selection.tools;
+      const toolDefinitions = tools.definitions;
+      const toolsByName = new Map(toolDefinitions.map((tool) => [tool.name, tool]));
+      const contextEvent = yield* hooks.trigger("session", "context", {
+        sessionID: selection.session.id,
+        agent: selection.agent.id,
+        model: model.ref,
+        system: [selection.agent.info.system ? selection.agent.info.system : base_default, history.initial].filter((part) => part.length > 0).map(SystemPart.make),
+        messages: [
+          ...toLLMMessages(history.messages, model.ref, providerMetadataKey),
+          ...history.instructionUpdate ? [Message.system(history.instructionUpdate)] : [],
+          Message.user(input.prompt)
+        ],
+        tools: Object.fromEntries(toolDefinitions.map((tool) => [
+          tool.name,
+          { description: tool.description, input: { ...tool.inputSchema } }
+        ]))
+      });
+      const hookedTools = Object.entries(contextEvent.tools).flatMap(([name, tool]) => {
+        const registered = toolsByName.get(name);
+        return registered ? [Object.assign({}, registered, { description: tool.description, inputSchema: tool.input })] : [];
+      });
+      yield* Effect.logInfo("sending session generation request", {
+        sessionID: selection.session.id,
+        providerID: model.ref.providerID,
+        modelID: model.ref.id
+      });
+      const response = yield* llm.generate(LLM.request({
+        model: model.model,
+        http: { headers: exports_model_headers.make(selection.session, app) },
+        promptCacheKey: exports_prompt_cache_key.make(selection.session.id),
+        system: contextEvent.system,
+        messages: contextEvent.messages,
+        tools: hookedTools
+      }));
+      yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage });
+      return response.text;
+    })
+  });
+}));
+var node = makeLocationNode({
+  service: exports_generate.Service,
+  layer,
+  deps: [exports_context.node, exports_database.node, exports_hooks.node, exports_model.node, exports_app.node, llmClient]
+});
+
+export { layer, node, exports_generate_node };

package/dist/chunks/permission-a83yvq99.js

@@ -0,0 +1,5 @@
+// src/session/event.ts
+export * from "@opencode-ai/schema/session-event";
+import * as SessionEvent from "@opencode-ai/schema/session-event";
+
+export { SessionEvent };