@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-g0dr00md.js

@@ -0,0 +1,260 @@
+import {
+  Metadata2,
+  useragent2,
+  node44
+} from "./repository-j4z2qnee.js";
+import {
+  provenance2,
+  compatible2
+} from "./repository-msq0jde0.js";
+import {
+  Service62,
+  node66
+} from "./repository-mgx963cj.js";
+import {
+  DeclinedError2
+} from "./repository-ykpr0q7c.js";
+import {
+  CancelledError2
+} from "./repository-rgmexsye.js";
+import {
+  Error3
+} from "./repository-39fveamk.js";
+import {
+  Service37,
+  node41
+} from "./repository-g8mks886.js";
+import {
+  make15
+} from "./repository-hjt4xg1x.js";
+import {
+  toLLMMessages2
+} from "./repository-p33ejz0k.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/model-request.ts
+var exports_model_request = {};
+__export(exports_model_request, {
+  Service: () => Service34,
+  SessionModelRequest: () => exports_model_request,
+  baseTranscript: () => baseTranscript2,
+  boundImages: () => boundImages2,
+  layer: () => layer14,
+  node: () => node39,
+  unsupportedParts: () => unsupportedParts2
+});
+import {
+  GenerationOptions,
+  HttpOptions,
+  LanguageModel,
+  LLM,
+  LLMRequest,
+  Message,
+  SystemPart
+} from "@opencode/ai";
+import { Cause, Context, Effect, Layer, Result, Stream } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var IMAGE_BYTES_TRIGGER = 25 * 1024 * 1024;
+var IMAGE_BYTES_TARGET = 15 * 1024 * 1024;
+var IMAGE_REMOVED = "[This image was removed to reduce the request size and is no longer visible. Do not make claims about its contents from memory. If needed, retrieve it again with an available tool or ask the user to attach it again.]";
+var GENERATION_KEYS = new Set(Object.keys(GenerationOptions.fields));
+var baseTranscript2 = (input) => {
+  const providerMetadataKey = input.model.model.route.providerMetadataKey ?? input.model.model.provider;
+  return {
+    providerMetadataKey,
+    system: [
+      input.agent.system ? input.agent.system : make15(input.tools.definitions.map((tool) => tool.name)),
+      input.initial
+    ].filter((part) => part.length > 0).map(SystemPart.make),
+    messages: toLLMMessages2(input.messages, input.model.ref, providerMetadataKey)
+  };
+};
+var mimeToModality = (mime) => {
+  if (mime.startsWith("image/"))
+    return "image";
+  if (mime.startsWith("audio/"))
+    return "audio";
+  if (mime.startsWith("video/"))
+    return "video";
+  if (mime === "application/pdf")
+    return "pdf";
+};
+var unsupportedMedia = (mime, name, capabilities) => {
+  const modality = mimeToModality(mime);
+  if (!modality || capabilities.input.some((item) => item.startsWith(modality)))
+    return;
+  return {
+    type: "text",
+    text: `ERROR: Cannot read ${name ? `"${name}"` : modality} (this model does not support ${modality} input). Inform the user.`
+  };
+};
+var unsupportedParts2 = (messages, capabilities) => messages.map((message) => Message.make({
+  ...message,
+  content: message.content.map((part) => {
+    if (part.type === "media") {
+      return unsupportedMedia(part.mediaType, part.filename, capabilities) ?? part;
+    }
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return part;
+    return {
+      ...part,
+      result: {
+        ...part.result,
+        value: part.result.value.map((item) => {
+          if (item.type !== "file")
+            return item;
+          return unsupportedMedia(item.mime, item.name, capabilities) ?? item;
+        })
+      }
+    };
+  })
+}));
+var boundImages2 = (messages) => {
+  const isImage = (mime) => mime.toLowerCase().startsWith("image/");
+  const size = (data) => typeof data === "string" ? Buffer.byteLength(data) : Math.ceil(data.byteLength / 3) * 4;
+  const imageBytes = messages.reduce((total, message) => total + message.content.reduce((sum, part) => {
+    if (part.type === "media" && isImage(part.mediaType))
+      return sum + size(part.data);
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return sum;
+    return sum + part.result.value.reduce((bytes, item) => bytes + (item.type === "file" && isImage(item.mime) ? Buffer.byteLength(item.uri) : 0), 0);
+  }, 0), 0);
+  if (imageBytes <= IMAGE_BYTES_TRIGGER)
+    return messages;
+  let removed = 0;
+  return messages.map((message) => Message.make({
+    ...message,
+    content: message.content.map((part) => {
+      if (part.type === "media" && isImage(part.mediaType) && imageBytes - removed > IMAGE_BYTES_TARGET) {
+        removed += size(part.data);
+        return Message.text(IMAGE_REMOVED);
+      }
+      if (part.type !== "tool-result" || part.result.type !== "content")
+        return part;
+      return {
+        ...part,
+        result: {
+          ...part.result,
+          value: part.result.value.map((item) => {
+            if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET)
+              return item;
+            removed += Buffer.byteLength(item.uri);
+            return { type: "text", text: IMAGE_REMOVED };
+          })
+        }
+      };
+    })
+  }));
+};
+
+class Service34 extends Context.Service()("@opencode/SessionModelRequest") {
+}
+var layer14 = Layer.effect(Service34, Effect.gen(function* () {
+  const hooks = yield* Service62;
+  const transport = yield* Service37;
+  const app = yield* Metadata2;
+  const prepare = Effect.fn("SessionModelRequest.prepare")(function* (kind, input, shape) {
+    const session = input.session;
+    const model = input.model;
+    const scope = { sessionID: session.id, agent: input.agent, model: model.ref, kind };
+    const tools = input.tools ?? {
+      definitions: [],
+      execute: () => new Error3({ message: "Tools are not available for this request" })
+    };
+    const given = new Map(tools.definitions.map((t) => [{ description: t.description, input: { ...t.inputSchema } }, t]));
+    const shaped = yield* shape({ sessionID: session.id, model: model.ref, system: input.system, messages: input.messages, options: {} }, Object.fromEntries(Array.from(given, ([d, t]) => [t.name, d])));
+    const byName = new Map(tools.definitions.map((t) => [t.name, t]));
+    const hooked = new Map(Object.entries(shaped.tools ?? {}).flatMap(([name, d]) => {
+      const t = given.get(d) ?? byName.get(name);
+      return t ? [[name, { ...t, description: d.description, inputSchema: d.input }]] : [];
+    }));
+    const entries = Object.entries(shaped.options);
+    const generation = Object.fromEntries(entries.filter(([k]) => GENERATION_KEYS.has(k)));
+    const providerOptions = Object.fromEntries(entries.filter(([k]) => !GENERATION_KEYS.has(k)));
+    const root = session.fork?.sessionID ?? session.id;
+    const base = LLM.request({
+      model: model.model,
+      http: {
+        headers: {
+          "x-session-affinity": session.id,
+          "X-Session-Id": session.id,
+          ...session.parentID ? { "x-parent-session-id": session.parentID } : {},
+          "User-Agent": useragent2(app),
+          "x-opencode-project": session.projectID,
+          "x-opencode-session": session.id,
+          "x-opencode-client": app.name
+        }
+      },
+      promptCacheKey: /^ses_[0-9a-f]{64}$/.test(root) ? root.slice(4) : root,
+      system: shaped.system,
+      messages: boundImages2(unsupportedParts2(shaped.messages, model.capabilities)),
+      tools: Array.from(hooked, ([name, t]) => ({ ...t, name })),
+      toolChoice: input.toolChoice,
+      generation: Object.keys(generation).length === 0 ? undefined : generation,
+      providerOptions: Object.keys(providerOptions).length === 0 ? undefined : providerOptions
+    });
+    const baseURL = base.model.route.endpoint.baseURL;
+    const modelHook = yield* hooks.trigger("session", "model.request", {
+      ...scope,
+      baseURL: typeof baseURL === "string" ? baseURL : undefined,
+      headers: { ...base.http?.headers }
+    });
+    const route = modelHook.baseURL !== undefined && modelHook.baseURL !== baseURL ? base.model.route.with({ endpoint: { baseURL: modelHook.baseURL } }) : base.model.route;
+    const request = LLMRequest.update(base, {
+      model: route === base.model.route ? base.model : LanguageModel.update(base.model, { route }),
+      http: new HttpOptions({
+        body: base.http?.body,
+        headers: Object.keys(modelHook.headers).length === 0 ? undefined : modelHook.headers,
+        query: base.http?.query
+      })
+    });
+    const selected = provenance2(model);
+    if (selected && !compatible2(selected, provenance2({ model: request.model, ref: model.ref })) && request.messages.some((message) => message.content.some((part) => part.type === "compaction")))
+      return yield* Effect.die(new Error("Provider context is incompatible with the route selected by model request hooks"));
+    const hasHttpHooks = (yield* hooks.has("session", "http.request", model.ref.providerID)) || (yield* hooks.has("session", "http.response", model.ref.providerID));
+    const http = hasHttpHooks ? (req, handler) => Effect.gen(function* () {
+      const before = yield* hooks.trigger("session", "http.request", {
+        ...scope,
+        request: yield* HttpClientRequest.toWeb(req)
+      });
+      let sent = HttpClientRequest.fromWeb(before.request);
+      if (before.request.body)
+        sent = HttpClientRequest.bodyUint8Array(sent, new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())), before.request.headers.get("content-type") ?? undefined);
+      const res = yield* handler(sent);
+      const after = yield* hooks.trigger("session", "http.response", {
+        ...scope,
+        request: before.request,
+        response: new Response([204, 205, 304].includes(res.status) ? null : yield* Stream.toReadableStreamEffect(res.stream), { status: res.status, headers: res.headers })
+      });
+      return HttpClientResponse.fromWeb(sent, after.response);
+    }).pipe(Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause)))) : undefined;
+    const webSocket = input.webSocket === "session" && !hasHttpHooks && model.capabilities.responsesWebsockets === true && model.websocket;
+    return {
+      event: shaped,
+      request,
+      options: { ...http ? { http } : {}, ...webSocket ? { webSocket: transport.bind(session.id) } : {} },
+      retry: (event) => hooks.trigger("session", "retry", event).pipe(Effect.asVoid),
+      executeTool: (call) => tools.execute({ ...call, definitions: hooked }).pipe(Effect.catchCauseFilter((cause) => {
+        const decline = cause.reasons.flatMap((r) => Cause.isDieReason(r) && (r.defect instanceof DeclinedError2 || r.defect instanceof CancelledError2) ? [r.defect] : [])[0];
+        return decline ? Result.succeed(decline) : Result.fail(cause);
+      }, (decline) => Effect.fail(decline)))
+    };
+  });
+  const agentHook = (name, agent) => (draft, tools) => hooks.trigger("session", name, { ...draft, agent, tools });
+  return Service34.of({
+    primary: (input) => prepare("primary", input, agentHook("context", input.agent)),
+    compaction: (input) => prepare("compaction", input, agentHook("compaction", input.agent)),
+    generate: (input) => prepare("generate", input, agentHook("generate", input.agent)),
+    title: (input) => prepare("title", input, (draft) => hooks.trigger("session", "title", draft))
+  });
+}));
+var node39 = makeLocationNode({
+  service: Service34,
+  layer: layer14,
+  deps: [node66, node41, node44]
+});
+
+export { baseTranscript2, unsupportedParts2, boundImages2, Service34, layer14, node39, exports_model_request };

package/dist/chunks/repository-g190xswt.js

@@ -0,0 +1,41 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/permission.ts
+var exports_permission = {};
+__export(exports_permission, {
+  Action: () => Action2,
+  ConfigPermissionV1: () => exports_permission,
+  Info: () => Info16,
+  Object: () => Object2,
+  Rule: () => Rule2
+});
+import { Schema, SchemaGetter } from "effect";
+var Action2 = Schema.Literals(["ask", "allow", "deny"]).annotate({ identifier: "PermissionActionConfig" });
+var Object2 = Schema.Record(Schema.String, Action2).annotate({ identifier: "PermissionObjectConfig" });
+var Rule2 = Schema.Union([Action2, Object2]).annotate({ identifier: "PermissionRuleConfig" });
+var InputObject = Schema.StructWithRest(Schema.Struct({
+  read: Schema.optional(Rule2),
+  edit: Schema.optional(Rule2),
+  glob: Schema.optional(Rule2),
+  grep: Schema.optional(Rule2),
+  list: Schema.optional(Rule2),
+  bash: Schema.optional(Rule2),
+  task: Schema.optional(Rule2),
+  external_directory: Schema.optional(Rule2),
+  question: Schema.optional(Action2),
+  webfetch: Schema.optional(Rule2),
+  websearch: Schema.optional(Action2),
+  lsp: Schema.optional(Rule2),
+  doom_loop: Schema.optional(Action2),
+  skill: Schema.optional(Rule2)
+}), [Schema.Record(Schema.String, Rule2)]);
+var InputSchema = Schema.Union([Action2, InputObject]);
+var normalizeInput = (input) => typeof input === "string" ? { "*": input } : input;
+var Info16 = InputSchema.pipe(Schema.decodeTo(InputObject, {
+  decode: SchemaGetter.transform(normalizeInput),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "PermissionConfig" });
+
+export { Action2, Object2, Rule2, Info16, exports_permission };

package/dist/chunks/repository-g4kbd5hn.js

@@ -0,0 +1,202 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  OAuth3,
+  Event19
+} from "./repository-sztg2hv4.js";
+import {
+  ID13,
+  MethodID2
+} from "./repository-0zkv00cg.js";
+import {
+  ID16,
+  packageName2,
+  mergeOverlay2
+} from "./repository-pye8sh6e.js";
+import {
+  iife2
+} from "./repository-1kg9ymc8.js";
+import {
+  which2
+} from "./repository-qaymkmh1.js";
+import {
+  configuredSettings2
+} from "./repository-5b88mxz1.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)
+}));
+var AzurePlugin2 = define({
+  id: "opencode.provider.azure",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(ID16.azure);
+    const processes = yield* AppProcess.Service;
+    const bus = yield* Service78;
+    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: ID16.azure,
+        method: { type: "key", label: "API key", form: form() }
+      });
+      if (!available)
+        return;
+      editor.method.update({
+        integrationID: ID16.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(ID16.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 !== ID16.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;
+              draft.websocket = true;
+            }
+          });
+        }
+      }
+    });
+    const reload = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID13.make("azure")), Stream.runForEach(reload), Effect.forkScoped({ startImmediately: true }));
+    yield* ctx.session.hook("http.request", (evt) => Effect.gen(function* () {
+      if (evt.model.providerID !== ID16.azure)
+        return;
+      const connection = yield* ctx.integration.connection.active(ID16.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: ID16.azure });
+  })
+});
+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/repository-g4wezp1m.js

@@ -0,0 +1,14 @@
+// src/github-copilot/chat/get-response-metadata.ts
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined
+  };
+}
+
+export { getResponseMetadata2 };

package/dist/chunks/repository-g86h250q.js

@@ -0,0 +1,17 @@
+// src/database/migration/20260303231226_add_workspace_fields.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260303231226_add_workspace_fields",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`type\` text NOT NULL;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`name\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`directory\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` ADD \`extra\` text;`);
+      yield* tx.run(`ALTER TABLE \`workspace\` DROP COLUMN \`config\`;`);
+    });
+  }
+};
+var _20260303231226_add_workspace_fields_default = migration;
+
+export { _20260303231226_add_workspace_fields_default };

package/dist/chunks/repository-g8d3gcyj.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/v1/config/command.ts
+var exports_command4 = {};
+__export(exports_command4, {
+  ConfigCommandV1: () => exports_command4,
+  Info: () => Info15
+});
+import { Schema } from "effect";
+var Info15 = Schema.Struct({
+  template: Schema.String,
+  description: Schema.optional(Schema.String),
+  agent: Schema.optional(Schema.String),
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String),
+  subtask: Schema.optional(Schema.Boolean)
+});
+
+export { Info15, exports_command4 };