@opencode-ai/core 0.0.0-beta-18721 → 0.0.0-beta-18866

package/dist/chunks/{workspace-n2dez5xq.js → reference-f6687h7n.js}

@@ -1,33 +1,57 @@
 import {
-  exports_generate
-} from "./workspace-xgv25zxy.js";
-import {
-  exports_session
-} from "./workspace-ypm2r7kk.js";
+  exports_command
+} from "./reference-rzv103sq.js";
 import {
-  exports_model_transport
-} from "./workspace-tjrfm0xh.js";
+  exports_generate
+} from "./reference-w7agyzeg.js";
 import {
   exports_projector
-} from "./workspace-d6597cvr.js";
+} from "./reference-mq1tw6ze.js";
+import {
+  DestinationNotDirectoryError,
+  DestinationNotFoundError,
+  DestinationUnavailableError,
+  exports_move
+} from "./reference-vyxqdbzy.js";
 import {
   exports_instruction_entry
-} from "./workspace-spxah02e.js";
+} from "./reference-80jq34sk.js";
+import {
+  exports_session
+} from "./reference-4z6b1r7t.js";
 import {
   exports_execution
-} from "./workspace-6c4zjnsa.js";
+} from "./reference-9ex87gzq.js";
 import {
   exports_inbox
-} from "./workspace-byb06gyb.js";
+} from "./reference-3t5c6jt3.js";
+import {
+  exports_service
+} from "./reference-6bxzghb6.js";
+import {
+  exports_model_transport
+} from "./reference-jr5m26np.js";
 import {
-  exports_supervisor_service
-} from "./workspace-s33fw6zm.js";
+  llmClient
+} from "./reference-326j4s6w.js";
 import {
   exports_app
-} from "./workspace-50jxp3hw.js";
+} from "./reference-hs51b0fc.js";
+import {
+  Slug
+} from "./reference-df3v2q6j.js";
+import {
+  exports_job
+} from "./reference-s4nkbdgv.js";
+import {
+  exports_environment
+} from "./reference-zn935gjz.js";
+import {
+  exports_location_service_map
+} from "./reference-c8z1ewty.js";
 import {
   exports_store
-} from "./workspace-se07g09y.js";
+} from "./reference-bwqptwn6.js";
 import {
   AttachmentError,
   BusyError,
@@ -43,105 +67,78 @@ import {
   PromptConflictError,
   SkillNotFoundError,
   SyntheticConflictError
-} from "./workspace-cgqn2mrm.js";
+} from "./reference-2sqw2jjm.js";
 import {
   exports_instruction_state
-} from "./workspace-0687t5rp.js";
+} from "./reference-m3k5wttq.js";
 import {
   SessionMessageTable
-} from "./workspace-q606pcse.js";
-import {
-  SessionEvent
-} from "./workspace-a83yvq99.js";
-import {
-  exports_job
-} from "./workspace-0t4s47ed.js";
+} from "./reference-q606pcse.js";
 import {
   SessionMessage
-} from "./workspace-8rpfd2h6.js";
-import {
-  exports_command
-} from "./workspace-zq1g42ep.js";
-import {
-  Slug
-} from "./workspace-df3v2q6j.js";
-import {
-  exports_environment
-} from "./workspace-6ky7rqk7.js";
+} from "./reference-8rpfd2h6.js";
 import {
   ID,
   Info,
   SessionSchema
-} from "./workspace-bjwj8hwv.js";
-import {
-  exports_location_service_map
-} from "./workspace-zdkg1k91.js";
+} from "./reference-bjwj8hwv.js";
 import {
-  exports_location
-} from "./workspace-ngk06vjf.js";
+  SessionEvent
+} from "./reference-a83yvq99.js";
 import {
   exports_project
-} from "./workspace-q2jbdv9f.js";
+} from "./reference-2syg46b4.js";
 import {
-  AbsolutePath,
   RelativePath
-} from "./workspace-j07kk359.js";
+} from "./reference-j07kk359.js";
 import {
   exports_bus
-} from "./workspace-vkgwd1zr.js";
+} from "./reference-jghhn6h0.js";
 import {
   exports_database
-} from "./workspace-gbf8gmfy.js";
+} from "./reference-xwpxh8hr.js";
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/session.ts
 var exports_session2 = {};
 __export(exports_session2, {
-  node: () => node,
-  SyntheticConflictError: () => SyntheticConflictError,
-  SkillNotFoundError: () => SkillNotFoundError,
-  SessionSchema: () => SessionSchema,
-  Session: () => exports_session2,
-  Service: () => Service,
-  PromptConflictError: () => PromptConflictError,
-  NotFoundError: () => NotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageDecodeError: () => MessageDecodeError,
-  ListInput: () => ListInput,
-  ListAnchor: () => ListAnchor,
-  Info: () => Info,
-  InboxConflictError: () => InboxConflictError,
-  ID: () => ID,
-  DestinationUnavailableError: () => DestinationUnavailableError,
-  DestinationNotFoundError: () => DestinationNotFoundError,
-  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
-  CompactionConflictError: () => CompactionConflictError,
+  AttachmentError: () => AttachmentError,
   BusyError: () => BusyError,
-  AttachmentError: () => AttachmentError
+  CompactionConflictError: () => CompactionConflictError,
+  DestinationNotDirectoryError: () => DestinationNotDirectoryError,
+  DestinationNotFoundError: () => DestinationNotFoundError,
+  DestinationUnavailableError: () => DestinationUnavailableError,
+  ID: () => ID,
+  InboxConflictError: () => InboxConflictError,
+  Info: () => Info,
+  ListAnchor: () => ListAnchor,
+  ListInput: () => ListInput,
+  MessageDecodeError: () => MessageDecodeError,
+  MessageIncompleteError: () => MessageIncompleteError,
+  MessageNotAssistantError: () => MessageNotAssistantError,
+  MessageNotFoundError: () => MessageNotFoundError,
+  MessageToolIncompleteError: () => MessageToolIncompleteError,
+  NotFoundError: () => NotFoundError,
+  PromptConflictError: () => PromptConflictError,
+  Service: () => Service,
+  Session: () => exports_session2,
+  SessionSchema: () => SessionSchema,
+  SkillNotFoundError: () => SkillNotFoundError,
+  SyntheticConflictError: () => SyntheticConflictError,
+  node: () => node
 });
-import { Cause, Effect, Layer, Schema, Context, RcMap, Stream } from "effect";
+import { Effect, Layer, Schema, Context, Stream } from "effect";
+import { LLMClient } from "@opencode-ai/ai";
 import { ListAnchor } from "@opencode-ai/schema/session";
 import { and, desc, eq } from "drizzle-orm";
 import { Model } from "@opencode-ai/schema/model";
 import path from "path";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
+import { Node } from "@opencode-ai/util/effect/app-node";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { Global } from "@opencode-ai/util/global";
 var ListInput = exports_store.ListInput;
-class DestinationNotFoundError extends Schema.TaggedError()("Session.DestinationNotFoundError", { directory: AbsolutePath }) {
-}
-
-class DestinationNotDirectoryError extends Schema.TaggedError()("Session.DestinationNotDirectoryError", { directory: AbsolutePath }) {
-}
-
-class DestinationUnavailableError extends Schema.TaggedError()("Session.DestinationUnavailableError", { directory: AbsolutePath }) {
-}
-
 class Service extends Context.Service()("@opencode/Session") {
 }
 var layer = Layer.effect(Service, Effect.gen(function* () {
@@ -152,22 +149,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const projects = yield* exports_project.Service;
   const global = yield* Global.Service;
   const execution = yield* exports_execution.Service;
+  const llm = yield* LLMClient.Service;
+  const transport = yield* exports_model_transport.Service;
   const store = yield* exports_store.Service;
+  const instances = yield* exports_service.Service;
   const locations = yield* exports_location_service_map.Service;
   const fs = yield* FSUtil.Service;
   const jobs = yield* exports_job.Service;
   const environments = yield* exports_environment.Service;
-  const sessions = yield* exports_session.make((ref) => locations.get(ref));
+  const sessions = yield* exports_session.make();
   const admission = yield* exports_inbox.Service;
-  const closeTransport = Effect.fn("Session.closeTransport")(function* (session) {
-    const location = exports_location.Ref.make({
-      directory: session.location.directory,
-      workspaceID: session.location.workspaceID
-    });
-    if (!(yield* RcMap.has(locations.rcMap, location)))
-      return;
-    yield* exports_model_transport.Service.use((transport) => transport.close(session.id)).pipe(Effect.provide(locations.get(location)));
-  });
   const isDurableSessionEvent = Schema.is(SessionEvent.Durable);
   const result = Service.of({
     create: Effect.fn("Session.create")(function* (input) {
@@ -240,10 +231,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }),
     view: (input) => sessions.forSession(input.sessionID).view(input),
     remove: Effect.fn("Session.remove")(function* (sessionID) {
-      const session = yield* result.get(sessionID);
+      yield* result.get(sessionID);
       yield* execution.interrupt(sessionID);
       yield* execution.awaitIdle(sessionID);
-      yield* closeTransport(session);
+      yield* transport.close(sessionID);
       const children = yield* result.list({ parentID: sessionID });
       yield* Effect.forEach(children.data, (child) => result.remove(child.id), { concurrency: 1, discard: true });
       yield* environments.clear(sessionID);
@@ -271,30 +262,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     prompt: (input) => sessions.forSession(input.sessionID).prompt(input),
     generate: Effect.fn("Session.generate")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      const generate = yield* exports_generate.Service.pipe(Effect.provide(locations.get(session.location)));
-      return yield* generate.generate(input);
+      return yield* exports_generate.generate({ session, prompt: input.prompt }).pipe(Effect.provideService(exports_service.Service, instances), Effect.provideService(exports_database.Service, database), Effect.provideService(LLMClient.Service, llm));
     }),
     command: Effect.fn("Session.command")(function* (input) {
       const session = yield* result.get(input.sessionID);
-      const commands = yield* Effect.gen(function* () {
-        const plugins = yield* exports_supervisor_service.Service;
-        yield* plugins.flush;
-        return yield* exports_command.Service;
-      }).pipe(Effect.provide(locations.get(session.location)));
-      const delivery = input.delivery ?? "steer";
-      yield* commands.execute({
-        name: input.command,
-        invocation: {
-          sessionID: input.sessionID,
-          prompt: {
-            text: input.text,
-            files: input.files,
-            agents: input.agents,
-            skills: input.skills
-          },
-          delivery
-        }
-      });
+      return yield* exports_command.execute({ ...input, session }).pipe(Effect.provideService(exports_service.Service, instances));
     }),
     shell: (input) => sessions.forSession(input.sessionID).shell(input),
     skill: (input) => sessions.forSession(input.sessionID).skill(input),
@@ -302,28 +274,8 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     switchModel: (input) => sessions.forSession(input.sessionID).switchModel(input),
     rename: (input) => sessions.forSession(input.sessionID).rename(input),
     move: Effect.fn("Session.move")(function* (input) {
-      const current = yield* result.get(input.sessionID);
-      const value = input.directory.trim();
-      const expanded = value === "~" ? global.home : value.startsWith("~/") ? path.join(global.home, value.slice(2)) : value;
-      const directory = AbsolutePath.make(path.resolve(current.location.directory, expanded));
-      const info = yield* fs.stat(directory).pipe(Effect.orElseSucceed(() => {
-        return;
-      }));
-      if (!info)
-        return yield* new DestinationNotFoundError({ directory });
-      if (info.type !== "Directory")
-        return yield* new DestinationNotDirectoryError({ directory });
-      const project = yield* projects.resolve(directory);
-      const payload = {
-        location: exports_location.Ref.make({ directory, workspaceID: input.workspaceID }),
-        projectID: project.id,
-        subpath: RelativePath.make(path.relative(project.directory, directory).replaceAll("\\", "/"))
-      };
-      yield* exports_location.Service.pipe(Effect.provide(locations.get(payload.location)), Effect.scoped, Effect.catchCause((cause) => {
-        if (Cause.hasInterruptsOnly(cause))
-          return Effect.failCause(cause);
-        return Effect.logWarning("session move destination unavailable", { directory, cause }).pipe(Effect.andThen(Effect.fail(new DestinationUnavailableError({ directory }))));
-      }));
+      const session = yield* result.get(input.sessionID);
+      const payload = yield* exports_move.prepare({ ...input, session }).pipe(Effect.provideService(FSUtil.Service, fs), Effect.provideService(Global.Service, global), Effect.provideService(exports_project.Service, projects), Effect.provideService(exports_location_service_map.Service, locations));
       const item = exports_inbox.Item.make({
         type: "move",
         payload,
@@ -334,7 +286,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         const source = yield* fs.stat(latest.location.directory).pipe(Effect.orElseSucceed(() => {
           return;
         }));
-        if (!source || source.type !== "Directory") {
+        if ((!source || source.type !== "Directory") && !(yield* execution.isActive(input.sessionID))) {
           const cancellations = (yield* exports_inbox.moveIDs(db, input.sessionID)).map((item2) => [SessionEvent.InboxCancelled, { sessionID: input.sessionID, inboxID: item2.id }]);
           const moved = [SessionEvent.Moved, { sessionID: input.sessionID, ...payload }];
           const first = cancellations[0];
@@ -382,7 +334,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   return result;
 }));
-var node = makeGlobalNode({
+var node = Node.makeGlobalNode({
   service: Service,
   layer,
   deps: [
@@ -392,7 +344,10 @@ var node = makeGlobalNode({
     exports_bus.node,
     exports_project.node,
     exports_execution.node,
+    exports_model_transport.node,
+    llmClient,
     exports_store.node,
+    exports_service.node,
     exports_inbox.node,
     exports_location_service_map.node,
     exports_projector.node,
@@ -402,4 +357,4 @@ var node = makeGlobalNode({
   ]
 });
 
-export { ListAnchor, ListInput, DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError, Service, node, exports_session2 as exports_session };
+export { ListAnchor, ListInput, Service, node, exports_session2 as exports_session };

package/dist/chunks/{workspace-wg766mjt.js → reference-f821qzap.js}

@@ -1,12 +1,12 @@
 import {
   exports_catalog
-} from "./workspace-vd1d8tva.js";
+} from "./reference-m8dxe63b.js";
 import {
   exports_config
-} from "./workspace-m4a2h2aa.js";
+} from "./reference-4v53bvyt.js";
 import {
   exports_provider
-} from "./workspace-fex42j86.js";
+} from "./reference-zq5w46q0.js";
 
 // src/plugin/provider/configured.ts
 import { Effect, Option } from "effect";

package/dist/chunks/{workspace-zwavn0q8.js → reference-f85kjf82.js}

@@ -1,41 +1,41 @@
 import {
   exports_tool
-} from "./workspace-57ej80dx.js";
+} from "./reference-0gpahtwn.js";
 import {
   definition,
   effectiveName,
   execute,
   normalizeContent,
   normalizedName
-} from "./workspace-f1jj19e8.js";
+} from "./reference-f1jj19e8.js";
 import {
   exports_image
-} from "./workspace-kb2ag3w7.js";
+} from "./reference-qx3jf2qk.js";
 import {
   exports_wildcard
-} from "./workspace-y67x6rf6.js";
+} from "./reference-edxnhgvj.js";
 import {
   exports_hooks
-} from "./workspace-v2wshkax.js";
+} from "./reference-xws7arpm.js";
 import {
   exports_state
-} from "./workspace-x89rah0x.js";
+} from "./reference-b7rje112.js";
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/tool.ts
 var exports_tool2 = {};
 __export(exports_tool2, {
-  node: () => node,
-  Tool: () => exports_tool2,
-  TextContent: () => TextContent,
-  Service: () => Service,
-  RegistrationError: () => RegistrationError,
-  FileContent: () => FileContent,
-  Error: () => Error2,
+  CallID: () => CallID,
   Content: () => Content,
-  CallID: () => CallID
+  Error: () => Error2,
+  FileContent: () => FileContent,
+  RegistrationError: () => RegistrationError,
+  Service: () => Service,
+  TextContent: () => TextContent,
+  Tool: () => exports_tool2,
+  node: () => node
 });
 import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
 import { ToolDefinition } from "@opencode-ai/ai";
@@ -127,15 +127,24 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     name: "tool",
     initial: () => ({
       tools: new Map,
+      namespaces: new Map,
       errors: []
     }),
     draft: (draft) => ({
       list: () => Array.from(draft.tools.values()),
       get: (id) => draft.tools.get(id),
+      namespace: (namespace) => {
+        const error = namespaceError(namespace.name);
+        if (error) {
+          draft.errors.push({ kind: "namespace", name: namespace.name, namespace: namespace.name, error });
+          return;
+        }
+        draft.namespaces.set(namespace.name, { ...namespace });
+      },
       add: (tool) => {
         const error = registrationError(tool);
         if (error) {
-          draft.errors.push({ tool, error });
+          draft.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
           return;
         }
         const id = effectiveName(tool);
@@ -153,7 +162,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           tool.options = { ...tool.options, namespace: current.options?.namespace };
         const error = registrationError(tool);
         if (error) {
-          draft.errors.push({ tool, error });
+          draft.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
           return;
         }
         draft.tools.set(id, tool);
@@ -162,9 +171,9 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         draft.tools.delete(id);
       }
     }),
-    finalize: () => Effect.forEach(state.get().errors, ({ tool, error }) => Effect.logError("Skipping invalid tool registration", {
-      name: tool.name,
-      namespace: tool.options?.namespace,
+    finalize: () => Effect.forEach(state.get().errors, ({ kind, name, namespace, error }) => Effect.logError(`Skipping invalid ${kind} registration`, {
+      name,
+      namespace,
       error: error.message
     }), { discard: true })
   });
@@ -180,15 +189,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         active.set(name, tool);
       }
       const direct = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode === false));
-      const codemode = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
-      const codemodeEnabled = !whollyDisabled("execute", rules);
-      const codemodeTool = codemodeEnabled ? exports_tool.create(codemode, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
-      const codeModeCatalog = codemodeEnabled ? exports_tool.catalog(codemode) : undefined;
+      const codeModeTools = new Map(Array.from(active).filter(([, tool]) => tool.options?.codemode !== false));
+      const namespaces = state.get().namespaces;
+      const codeModeInventory = { tools: codeModeTools, namespaces };
+      const codeModeEnabled = !whollyDisabled("execute", rules);
+      const codeModeTool = codeModeEnabled ? exports_tool.create(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? exports_tool.catalog(codeModeInventory) : undefined;
       return {
         ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
         definitions: [
           ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition(tool)),
-          ...codemodeTool ? [definition(codemodeTool)] : []
+          ...codeModeTool ? [definition(codeModeTool)] : []
         ],
         execute: Effect.fnUntraced(function* (input) {
           const context = {
@@ -200,11 +211,11 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           };
           const event = yield* beforeExecute(input.call.name, input.call.input, context);
           const requested = input.definitions?.get(event.tool);
-          if (!requested && input.definitions && (direct.has(event.tool) || codemodeTool?.name === event.tool))
+          if (!requested && input.definitions && (direct.has(event.tool) || codeModeTool?.name === event.tool))
             return yield* new Tool.Error({ message: `Tool is not available for this request: ${event.tool}` });
           const name = requested?.name ?? event.tool;
-          if (name === "execute" && codemodeTool)
-            return yield* executeTool(codemodeTool, name, event.input, context);
+          if (name === "execute" && codeModeTool)
+            return yield* executeTool(codeModeTool, name, event.input, context);
           const tool = direct.get(name);
           if (tool)
             return yield* executeTool(tool, name, event.input, context);
@@ -226,8 +237,11 @@ function schemaMakeError(error) {
 }
 function registrationError(tool) {
   const namespace = tool.options?.namespace;
-  if (namespace !== undefined && !namespace.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
-    return new RegistrationError({ name: namespace, message: `Invalid tool namespace: ${JSON.stringify(namespace)}` });
+  if (namespace !== undefined) {
+    const error = namespaceError(namespace);
+    if (error)
+      return error;
+  }
   const name = normalizedName(tool);
   if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
     return new RegistrationError({ name, message: `Invalid tool name: ${name}` });
@@ -240,6 +254,11 @@ function registrationError(tool) {
   });
   return Result.isFailure(result) ? result.failure : undefined;
 }
+function namespaceError(name) {
+  if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
+    return;
+  return new RegistrationError({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+}
 var node = makeLocationNode({
   service: Service,
   layer,

package/dist/chunks/{workspace-41qzzbpz.js → reference-f8wvq04h.js}

@@ -1,12 +1,12 @@
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/session/run-coordinator.ts
 var exports_run_coordinator = {};
 __export(exports_run_coordinator, {
-  make: () => make,
-  SessionRunCoordinator: () => exports_run_coordinator
+  SessionRunCoordinator: () => exports_run_coordinator,
+  make: () => make
 });
 import { Deferred, Effect, Fiber, FiberSet } from "effect";
 var make = (options) => Effect.gen(function* () {

package/dist/chunks/{workspace-aweppgs5.js → reference-fddsdmdf.js}

@@ -1,15 +1,15 @@
 import {
   exports_config
-} from "./workspace-m4a2h2aa.js";
+} from "./reference-4v53bvyt.js";
 import {
   __export
-} from "./workspace-rvfvac9x.js";
+} from "./reference-vpjkya7h.js";
 
 // src/plugin/warming.ts
 var exports_warming = {};
 __export(exports_warming, {
-  WarmingPlugin: () => exports_warming,
-  Plugin: () => Plugin
+  Plugin: () => Plugin,
+  WarmingPlugin: () => exports_warming
 });
 import { define } from "@opencode-ai/plugin/effect/plugin";
 import { Clock, Duration, Effect, Scope } from "effect";

package/dist/chunks/reference-fkdrrz2d.js

@@ -0,0 +1,30 @@
+import {
+  exports_service
+} from "./reference-6bxzghb6.js";
+import {
+  exports_skill
+} from "./reference-k3b0087g.js";
+import {
+  SkillNotFoundError
+} from "./reference-2sqw2jjm.js";
+import {
+  __export
+} from "./reference-vpjkya7h.js";
+
+// src/session/skill.ts
+var exports_skill2 = {};
+__export(exports_skill2, {
+  SessionSkill: () => exports_skill2,
+  get: () => get
+});
+import { Effect } from "effect";
+var get = Effect.fn("SessionSkill.get")(function* (input) {
+  const instances = yield* exports_service.Service;
+  const skills = yield* exports_skill.Service.pipe(instances.provide(input.session));
+  const skill = yield* skills.get(input.skill);
+  if (!skill)
+    return yield* new SkillNotFoundError({ skill: input.skill });
+  return skill;
+});
+
+export { get, exports_skill2 as exports_skill };

package/dist/chunks/{workspace-tv8s8hx7.js → reference-fkf3c53e.js}

@@ -1,18 +1,18 @@
-import {
-  imageGenerationArgsSchema
-} from "./workspace-4b2tz2m9.js";
 import {
   webSearchArgsSchema
-} from "./workspace-gy500k2r.js";
+} from "./reference-gy500k2r.js";
 import {
-  webSearchPreviewArgsSchema
-} from "./workspace-7n9qwqk4.js";
+  fileSearchArgsSchema
+} from "./reference-wj4sxzqa.js";
 import {
   codeInterpreterArgsSchema
-} from "./workspace-5a5ch9ts.js";
+} from "./reference-5a5ch9ts.js";
 import {
-  fileSearchArgsSchema
-} from "./workspace-wj4sxzqa.js";
+  webSearchPreviewArgsSchema
+} from "./reference-7n9qwqk4.js";
+import {
+  imageGenerationArgsSchema
+} from "./reference-4b2tz2m9.js";
 
 // src/github-copilot/responses/openai-responses-prepare-tools.ts
 import {