@opencode-ai/core 0.0.0-next-17293

package/dist/chunks/permission-bha9y19b.js

@@ -0,0 +1,168 @@
+import {
+  InstructionBlobTable,
+  InstructionStateTable
+} from "./permission-zvvp2xr4.js";
+import {
+  SessionEvent
+} from "./permission-a83yvq99.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/instruction-state.ts
+var exports_instruction_state = {};
+__export(exports_instruction_state, {
+  reset: () => reset,
+  preview: () => preview,
+  prepare: () => prepare,
+  observe: () => observe,
+  initialize: () => initialize,
+  initial: () => initial,
+  current: () => current,
+  commit: () => commit,
+  apply: () => apply,
+  advanceEpoch: () => advanceEpoch,
+  InstructionState: () => exports_instruction_state
+});
+import { eq, inArray, sql } from "drizzle-orm";
+import { Effect, Option } from "effect";
+var observe = Effect.fn("InstructionState.observe")(function* (db, instructions, sessionID) {
+  const [observed, stored] = yield* Effect.all([exports_instructions.read(instructions), find(db, sessionID)], {
+    concurrency: "unbounded"
+  });
+  const result = yield* observeAgainst(observed, stored?.current_values);
+  return {
+    sessionID,
+    initial: !stored,
+    previous: stored?.current_values ?? {},
+    ...result
+  };
+});
+var commit = Effect.fn("InstructionState.commit")(function* (db, bus, instructions, observation) {
+  if (!observation.initial && Object.keys(observation.delta).length === 0)
+    return;
+  const text = observation.initial ? "" : yield* renderUpdateText(db, instructions, observation);
+  yield* bus.publish(SessionEvent.InstructionsUpdated, {
+    sessionID: observation.sessionID,
+    delta: observation.delta,
+    ...text.length > 0 ? { text } : {}
+  }, {
+    ...observation.initial ? { metadata: { instructions: { initial: true } } } : {},
+    commit: () => insertBlobs(db, observation.blobs)
+  });
+});
+var renderUpdateText = Effect.fnUntraced(function* (db, instructions, observation) {
+  const replaced = Object.entries(observation.previous).filter(([key]) => Object.hasOwn(observation.delta, key));
+  const blobs = yield* loadBlobs(db, replaced.map(([, hash]) => hash));
+  const previous = Object.fromEntries(replaced.map(([key, hash]) => [key, requireBlob(blobs, hash)]));
+  const admitted = new Map(Object.entries(observation.blobs).map(([hash, value]) => [exports_instructions.Hash.make(hash), value]));
+  return exports_instructions.renderUpdate(instructions, previous, dereferenceDelta(observation.delta, admitted));
+});
+var prepare = Effect.fn("InstructionState.prepare")(function* (db, bus, instructions, sessionID) {
+  yield* commit(db, bus, instructions, yield* observe(db, instructions, sessionID));
+});
+var apply = Effect.fn("InstructionState.apply")(function* (db, sessionID, seq, delta) {
+  const stored = yield* find(db, sessionID);
+  const current = exports_instructions.applyHashDelta(stored?.current_values ?? {}, delta);
+  if (!stored) {
+    yield* db.insert(InstructionStateTable).values({
+      session_id: sessionID,
+      epoch_start: seq,
+      through_seq: seq,
+      initial_values: current,
+      current_values: current
+    }).run().pipe(Effect.orDie);
+    return;
+  }
+  yield* db.update(InstructionStateTable).set({ through_seq: seq, current_values: current }).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var initialize = Effect.fn("InstructionState.initialize")(function* (db, sessionID, seq, values) {
+  yield* db.insert(InstructionStateTable).values({
+    session_id: sessionID,
+    epoch_start: seq,
+    through_seq: seq,
+    initial_values: values,
+    current_values: values
+  }).onConflictDoNothing().run().pipe(Effect.orDie);
+});
+var advanceEpoch = Effect.fn("InstructionState.advanceEpoch")(function* (db, sessionID, epochStart) {
+  yield* db.update(InstructionStateTable).set({
+    epoch_start: epochStart,
+    through_seq: epochStart,
+    initial_values: sql`${InstructionStateTable.current_values}`
+  }).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var reset = Effect.fn("InstructionState.reset")(function* (db, sessionID) {
+  yield* db.delete(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).run().pipe(Effect.orDie);
+});
+var initial = Effect.fn("InstructionState.initial")(function* (db, sessionID, instructions) {
+  const state = yield* find(db, sessionID);
+  if (!state)
+    return yield* Effect.die(new Error(`Instruction state not found during assembly: ${sessionID}`));
+  const blobs = yield* loadBlobs(db, Object.values(state.initial_values));
+  return exports_instructions.renderInitial(instructions, dereference(state.initial_values, blobs));
+});
+var current = Effect.fn("InstructionState.current")(function* (db, sessionID) {
+  return (yield* find(db, sessionID))?.current_values;
+});
+var preview = Effect.fn("InstructionState.preview")(function* (db, sessionID, instructions, observed) {
+  const state = yield* find(db, sessionID);
+  const result = yield* observeAgainst(observed, state?.current_values);
+  const observedBlobs = new Map(Object.entries(result.blobs).map(([hash, value]) => [exports_instructions.Hash.make(hash), value]));
+  if (!state) {
+    const values = dereference(result.current, observedBlobs);
+    return { initial: exports_instructions.renderInitial(instructions, values), update: "" };
+  }
+  const stored = yield* loadBlobs(db, [...Object.values(state.initial_values), ...Object.values(state.current_values)]);
+  return {
+    initial: exports_instructions.renderInitial(instructions, dereference(state.initial_values, stored)),
+    update: exports_instructions.renderUpdate(instructions, dereference(state.current_values, stored), dereferenceDelta(result.delta, new Map([...stored, ...observedBlobs])))
+  };
+});
+var observeAgainst = Effect.fnUntraced(function* (observed, previous) {
+  const admission = yield* exports_instructions.diff(observed, previous);
+  return {
+    current: exports_instructions.applyHashDelta(previous ?? {}, admission.delta),
+    ...admission
+  };
+});
+var find = Effect.fnUntraced(function* (db, sessionID) {
+  return yield* db.select().from(InstructionStateTable).where(eq(InstructionStateTable.session_id, sessionID)).get().pipe(Effect.orDie);
+});
+var insertBlobs = Effect.fnUntraced(function* (db, blobs) {
+  const rows = Object.entries(blobs).map(([hash, value]) => ({ hash: exports_instructions.Hash.make(hash), value }));
+  if (rows.length === 0)
+    return;
+  yield* db.insert(InstructionBlobTable).values(rows).onConflictDoNothing().run().pipe(Effect.orDie);
+});
+var loadBlobs = Effect.fnUntraced(function* (db, values) {
+  const hashes = [...new Set(values)];
+  const batches = Array.from({ length: Math.ceil(hashes.length / 500) }, (_, index) => hashes.slice(index * 500, (index + 1) * 500));
+  const rows = (yield* Effect.forEach(batches, (batch) => db.select().from(InstructionBlobTable).where(inArray(InstructionBlobTable.hash, batch)).all().pipe(Effect.orDie), { concurrency: 4 })).flat();
+  const blobs = new Map(rows.map((row) => [row.hash, row.value]));
+  for (const hash of hashes) {
+    if (!blobs.has(hash))
+      return yield* Effect.die(new Error(`Instruction blob not found: ${hash}`));
+  }
+  return blobs;
+});
+function dereference(values, blobs) {
+  return Object.fromEntries(Object.entries(values).map(([key, hash]) => [key, requireBlob(blobs, hash)]));
+}
+function dereferenceDelta(delta, blobs) {
+  return Object.fromEntries(Object.entries(delta).map(([key, hash]) => [
+    key,
+    hash === "removed" ? Option.none() : Option.some(requireBlob(blobs, hash))
+  ]));
+}
+function requireBlob(blobs, hash) {
+  const value = blobs.get(hash);
+  if (value === undefined)
+    throw new Error(`Instruction blob not found: ${hash}`);
+  return value;
+}
+
+export { observe, commit, prepare, apply, initialize, advanceEpoch, reset, initial, current, preview, exports_instruction_state };

package/dist/chunks/permission-brsh5f65.js

@@ -0,0 +1,146 @@
+// src/github-copilot/chat/convert-to-openai-compatible-chat-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { convertToBase64 } from "@ai-sdk/provider-utils";
+function getOpenAIMetadata(message) {
+  return message?.providerOptions?.copilot ?? {};
+}
+function convertToOpenAICompatibleChatMessages(prompt) {
+  const messages = [];
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content,
+          ...metadata
+        });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0])
+          });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part);
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text, ...partMetadata };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          }),
+          ...metadata
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoningText;
+        let reasoningOpaque;
+        const toolCalls = [];
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          const partOpaque = part.providerOptions?.copilot?.reasoningOpaque;
+          if (partOpaque && !reasoningOpaque) {
+            reasoningOpaque = partOpaque;
+          }
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              if (part.text)
+                reasoningText = part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                },
+                ...partMetadata
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          reasoning_text: reasoningOpaque ? reasoningText : undefined,
+          reasoning_opaque: reasoningOpaque,
+          ...metadata
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = output.reason ?? "Tool execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+
+export { convertToOpenAICompatibleChatMessages };

package/dist/chunks/permission-bxdhjb3y.js

@@ -0,0 +1,107 @@
+// src/database/drizzle/sqlite-core/effect/query.ts
+import { applyEffectWrapper } from "drizzle-orm/effect-core/query-effect";
+import { entityKind } from "drizzle-orm/entity";
+import {
+  makeDefaultRqbMapper
+} from "drizzle-orm/relations";
+import { sql } from "drizzle-orm/sql/sql";
+
+class SQLiteEffectRelationalQueryBuilder {
+  schema;
+  table;
+  tableConfig;
+  dialect;
+  session;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryBuilderV2";
+  constructor(schema, table, tableConfig, dialect, session, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.table = table;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+  }
+  findMany(config) {
+    return new SQLiteEffectRelationalQuery(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "many", this.rowMode, this.forbidJsonb);
+  }
+  findFirst(config) {
+    return new SQLiteEffectRelationalQuery(this.schema, this.table, this.tableConfig, this.dialect, this.session, config ?? true, "first", this.rowMode, this.forbidJsonb);
+  }
+}
+
+class SQLiteEffectRelationalQuery {
+  schema;
+  tableConfig;
+  dialect;
+  session;
+  config;
+  rowMode;
+  forbidJsonb;
+  static [entityKind] = "SQLiteEffectRelationalQueryV2";
+  mode;
+  table;
+  constructor(schema, table, tableConfig, dialect, session, config, mode, rowMode, forbidJsonb) {
+    this.schema = schema;
+    this.tableConfig = tableConfig;
+    this.dialect = dialect;
+    this.session = session;
+    this.config = config;
+    this.rowMode = rowMode;
+    this.forbidJsonb = forbidJsonb;
+    this.mode = mode;
+    this.table = table;
+  }
+  getSQL() {
+    return this._getQuery().sql;
+  }
+  _prepare(isOneTimeQuery = true) {
+    const { query, builtQuery } = this._toSQL();
+    const mapperConfig = {
+      isFirst: this.mode === "first",
+      parseJson: !this.rowMode,
+      parseJsonIfString: false,
+      rootJsonMappers: true,
+      selection: query.selection
+    };
+    return this.session[isOneTimeQuery ? "prepareOneTimeRelationalQuery" : "prepareRelationalQuery"](builtQuery, undefined, this.mode === "first" ? "get" : "all", makeDefaultRqbMapper(mapperConfig), mapperConfig);
+  }
+  prepare() {
+    return this._prepare(false);
+  }
+  _getQuery() {
+    const jsonb = this.forbidJsonb ? sql`json` : sql`jsonb`;
+    const query = this.dialect.buildRelationalQuery({
+      schema: this.schema,
+      table: this.table,
+      tableConfig: this.tableConfig,
+      queryConfig: this.config,
+      mode: this.mode,
+      isNested: this.rowMode,
+      jsonb
+    });
+    if (this.rowMode) {
+      const jsonColumns = sql.join(query.selection.map((s) => {
+        return sql`${sql.raw(this.dialect.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
+      }), sql`, `);
+      query.sql = sql`select json_object(${jsonColumns}) as ${sql.identifier("r")} from (${query.sql}) as ${sql.identifier("t")}`;
+    }
+    return query;
+  }
+  _toSQL() {
+    const query = this._getQuery();
+    const builtQuery = this.dialect.sqlToQuery(query.sql);
+    return { query, builtQuery };
+  }
+  toSQL() {
+    return this._toSQL().builtQuery;
+  }
+  execute(placeholderValues) {
+    return this.mode === "first" ? this._prepare().get(placeholderValues) : this._prepare().all(placeholderValues);
+  }
+}
+applyEffectWrapper(SQLiteEffectRelationalQuery);
+
+export { SQLiteEffectRelationalQueryBuilder, SQLiteEffectRelationalQuery };

package/dist/chunks/permission-byab506k.js

@@ -0,0 +1,14 @@
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/database/v1-migration.ts
+var exports_v1_migration = {};
+__export(exports_v1_migration, {
+  V1Migration: () => V1Migration
+});
+import * as V1Migration from "#v1-migration";
+
+export * from "#v1-migration";
+
+export { exports_v1_migration, V1Migration };

package/dist/chunks/permission-c5md9thr.js

@@ -0,0 +1,106 @@
+import {
+  fileDiff
+} from "./permission-c77ad0vh.js";
+import {
+  exports_file_mutation
+} from "./permission-2nkse5ac.js";
+import {
+  exports_formatter
+} from "./permission-w4678h5q.js";
+import {
+  exports_environment1 as exports_environment
+} from "./permission-z5ystmxz.js";
+import {
+  exports_location_mutation
+} from "./permission-a2yyszsy.js";
+import {
+  exports_permission
+} from "./permission-qa8qg9jd.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/tool/plugin/write.ts
+var exports_write = {};
+__export(exports_write, {
+  toModelOutput: () => toModelOutput,
+  name: () => name,
+  WriteTool: () => exports_write,
+  Plugin: () => Plugin,
+  Output: () => Output,
+  Input: () => Input
+});
+import { ToolFailure } from "@opencode-ai/ai";
+import { Effect, Schema } from "effect";
+import { Bom } from "@opencode-ai/util/bom";
+var name = "write";
+var Input = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "Path to the file to write to"
+  }),
+  content: Schema.String.annotate({ description: "Content to write to the file" })
+});
+var Output = Schema.Struct({
+  operation: Schema.Literal("write"),
+  target: Schema.String,
+  resource: Schema.String,
+  existed: Schema.Boolean
+});
+var toModelOutput = (output) => `${output.existed ? "Wrote" : "Created"} file successfully: ${output.resource}`;
+var Plugin = {
+  id: "opencode.tool.write",
+  effect: Effect.fn("WriteTool.Plugin")(function* (ctx) {
+    const mutation = yield* exports_location_mutation.Service;
+    const fileMutation = yield* exports_file_mutation.Service;
+    const environment = yield* exports_environment.Service;
+    const formatter = yield* exports_formatter.Service;
+    const permission = yield* exports_permission.Service;
+    yield* ctx.tool.transform((draft) => draft.add({
+      name,
+      options: { codemode: false, permission: "edit" },
+      description: `Writes a file to the local filesystem, overwriting if one exists.
+
+Missing parent directories are created automatically.
+
+Use this tool to create new files or overwrite existing files. For partial changes, use the edit tool instead.`,
+      input: Input,
+      output: Output,
+      execute: (input, context) => Effect.gen(function* () {
+        const source = {
+          type: "tool",
+          messageID: context.messageID,
+          id: context.id
+        };
+        const target = yield* mutation.resolve({ path: input.path, kind: "file" });
+        const external = target.externalDirectory;
+        if (external)
+          yield* permission.assert({
+            ...exports_location_mutation.externalDirectoryPermission(external),
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source
+          });
+        const current = yield* exports_file_mutation.readText(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.succeed(undefined)));
+        const next = Bom.split(input.content);
+        const preview = fileDiff(target.resource, current?.text ?? "", next.text, current ? "modified" : "added");
+        yield* permission.assert({
+          action: "edit",
+          resources: [target.resource],
+          save: ["*"],
+          metadata: { files: [preview] },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const result = yield* fileMutation.writeTextPreservingBom({ target, content: input.content });
+        const bom = (yield* exports_file_mutation.readText(environment.files, target.absolute)).bom;
+        if (yield* formatter.file(target.absolute)) {
+          yield* exports_file_mutation.syncTextBom(environment.files, target.absolute, bom);
+        }
+        return result;
+      }).pipe(Effect.map((output) => ({ output, content: toModelOutput(output) })), Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name, Input, Output, toModelOutput, Plugin, exports_write };

package/dist/chunks/permission-c77ad0vh.js

@@ -0,0 +1,16 @@
+// src/tool/plugin/file-diff.ts
+import { createTwoFilesPatch, diffLines } from "diff";
+function fileDiff(file, before, after, status = "modified") {
+  const counts = diffLines(before, after).reduce((result, item) => ({
+    additions: result.additions + (item.added ? item.count ?? 0 : 0),
+    deletions: result.deletions + (item.removed ? item.count ?? 0 : 0)
+  }), { additions: 0, deletions: 0 });
+  return {
+    file,
+    patch: createTwoFilesPatch(file, file, before, after),
+    status,
+    ...counts
+  };
+}
+
+export { fileDiff };

package/dist/chunks/permission-c8dztf94.js

@@ -0,0 +1,90 @@
+import {
+  InstructionEntryTable
+} from "./permission-zvvp2xr4.js";
+import {
+  exports_instructions
+} from "./permission-q4r4pzs4.js";
+import {
+  exports_database
+} from "./permission-8w2n8x74.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/session/instruction-entry.ts
+var exports_instruction_entry = {};
+__export(exports_instruction_entry, {
+  node: () => node,
+  ValueTooLargeError: () => ValueTooLargeError,
+  Service: () => Service,
+  MaxValueBytes: () => MaxValueBytes,
+  Key: () => Key,
+  InstructionEntry: () => exports_instruction_entry,
+  Info: () => Info
+});
+import { and, asc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { Context, Effect, Layer, Schema } from "effect";
+import { InstructionEntry } from "@opencode-ai/schema/instruction-entry";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+var Key = InstructionEntry.Key;
+var Info = InstructionEntry.Info;
+var MaxValueBytes = InstructionEntry.MaxValueBytes;
+var ValueTooLargeError = InstructionEntry.ValueTooLargeError;
+
+class Service extends Context.Service()("@opencode/InstructionEntry") {
+}
+var renderValue = (value) => typeof value === "string" ? value : JSON.stringify(value, null, 2);
+var renderBlock = (key, value) => [`<context key="${key}">`, renderValue(value), "</context>"].join(`
+`);
+var source = (entry) => exports_instructions.make({
+  key: exports_instructions.Key.make(`api/${entry.key}`),
+  codec: Schema.toCodecJson(Schema.Json),
+  read: Effect.succeed(entry.removed ? exports_instructions.removed : entry.value),
+  render: {
+    initial: (value) => renderBlock(entry.key, value),
+    changed: (_previous, value) => [
+      `The context under "${entry.key}" changed and supersedes the previous value:`,
+      renderBlock(entry.key, value)
+    ].join(`
+`),
+    removed: () => `The context under "${entry.key}" no longer applies. Disregard it.`
+  }
+});
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const { db } = yield* exports_database.Service;
+  const rows = Effect.fnUntraced(function* (sessionID, includeRemoved) {
+    return yield* db.select({
+      key: InstructionEntryTable.key,
+      value: InstructionEntryTable.value,
+      removed: InstructionEntryTable.removed
+    }).from(InstructionEntryTable).where(and(eq(InstructionEntryTable.session_id, sessionID), includeRemoved ? undefined : eq(InstructionEntryTable.removed, false))).orderBy(asc(InstructionEntryTable.key)).all().pipe(Effect.orDie);
+  });
+  const list = Effect.fn("InstructionEntry.list")(function* (sessionID) {
+    return (yield* rows(sessionID, false)).map((row) => ({ key: row.key, value: row.value }));
+  });
+  const put = Effect.fn("InstructionEntry.put")(function* (input) {
+    const actualBytes = Buffer.byteLength(JSON.stringify(input.value), "utf8");
+    if (actualBytes > MaxValueBytes)
+      yield* new ValueTooLargeError({
+        actualBytes,
+        maxBytes: MaxValueBytes,
+        message: `Instruction entry value is ${actualBytes} bytes; the limit is ${MaxValueBytes} bytes`
+      });
+    const changed = input.value === null ? isNotNull(InstructionEntryTable.value) : or(isNull(InstructionEntryTable.value), ne(InstructionEntryTable.value, input.value));
+    yield* db.insert(InstructionEntryTable).values({ session_id: input.sessionID, key: input.key, value: input.value, removed: false }).onConflictDoUpdate({
+      target: [InstructionEntryTable.session_id, InstructionEntryTable.key],
+      set: { value: input.value, removed: false, time_updated: Date.now() },
+      setWhere: or(eq(InstructionEntryTable.removed, true), changed)
+    }).run().pipe(Effect.orDie);
+  });
+  const remove = Effect.fn("InstructionEntry.remove")(function* (input) {
+    yield* db.update(InstructionEntryTable).set({ value: null, removed: true, time_updated: Date.now() }).where(and(eq(InstructionEntryTable.session_id, input.sessionID), eq(InstructionEntryTable.key, input.key), eq(InstructionEntryTable.removed, false))).run().pipe(Effect.orDie);
+  });
+  const load = Effect.fn("InstructionEntry.load")(function* (sessionID) {
+    return exports_instructions.combine((yield* rows(sessionID, true)).map(source));
+  });
+  return Service.of({ list, put, remove, load });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_database.node] });
+
+export { Key, Info, MaxValueBytes, ValueTooLargeError, Service, node, exports_instruction_entry };

package/dist/chunks/permission-cd4w01s5.js

@@ -0,0 +1,30 @@
+import {
+  exports_config
+} from "./permission-k59zb4v2.js";
+import {
+  __export
+} from "./permission-rvfvac9x.js";
+
+// src/config/plugin/websearch.ts
+var exports_websearch = {};
+__export(exports_websearch, {
+  Plugin: () => Plugin,
+  ConfigWebSearchPlugin: () => exports_websearch
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.websearch",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const loaded = { entries: yield* config.entries() };
+    yield* ctx.websearch.transform((websearch) => {
+      const providerID = exports_config.latest(loaded.entries, "websearch")?.provider;
+      if (providerID)
+        websearch.default.set(providerID);
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(ctx.websearch.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin, exports_websearch };