@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-4b2tz2m9.js

@@ -0,0 +1,22 @@
+// src/github-copilot/responses/tool/image-generation.ts
+import { z } from "zod/v4";
+var imageGenerationArgsSchema = z.object({
+  background: z.enum(["auto", "opaque", "transparent"]).optional(),
+  inputFidelity: z.enum(["low", "high"]).optional(),
+  inputImageMask: z.object({
+    fileId: z.string().optional(),
+    imageUrl: z.string().optional()
+  }).optional(),
+  model: z.string().optional(),
+  moderation: z.enum(["auto"]).optional(),
+  outputCompression: z.number().int().min(0).max(100).optional(),
+  outputFormat: z.enum(["png", "jpeg", "webp"]).optional(),
+  partialImages: z.number().int().min(0).max(3).optional(),
+  quality: z.enum(["auto", "low", "medium", "high"]).optional(),
+  size: z.enum(["1024x1024", "1024x1536", "1536x1024", "auto"]).optional()
+}).strict();
+var imageGenerationOutputSchema = z.object({
+  result: z.string()
+});
+
+export { imageGenerationArgsSchema, imageGenerationOutputSchema };

package/dist/chunks/ripgrep-4ffc1teg.js

@@ -0,0 +1,120 @@
+import {
+  exports_state
+} from "./ripgrep-wt193r4g.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  node: () => node,
+  defaultID: () => defaultID,
+  Service: () => Service,
+  Name: () => Name,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  Color: () => Color,
+  Agent: () => exports_agent
+});
+import path from "path";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Array, Context, Effect, Layer } from "effect";
+import { Agent } from "@opencode-ai/schema/agent";
+import { Global } from "@opencode-ai/util/global";
+import { Event } from "@opencode-ai/schema/agent";
+var SHELL_OUTPUT_GLOB = (data) => path.join(data, "shell", "*", "*");
+var TOOL_OUTPUT_GLOB = (data) => path.join(data, "tool-output", "*");
+var ID = Agent.ID;
+var Name = Agent.Name;
+var defaultID = ID.make("build");
+var Color = Agent.Color;
+var Info = Agent.Info;
+
+class Service extends Context.Service()("@opencode/Agent") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const global = yield* Global.Service;
+  const permissions = [
+    { action: "external_directory", resource: SHELL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: TOOL_OUTPUT_GLOB(global.data), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.tmp, "*"), effect: "allow" },
+    { action: "external_directory", resource: path.join(global.config, "*"), effect: "allow" }
+  ];
+  const state = exports_state.create({
+    name: "agent",
+    initial: () => ({ agents: new Map }),
+    draft: (draft) => ({
+      list: () => Array.fromIterable(draft.agents.values()),
+      get: (id) => draft.agents.get(id),
+      default: (id) => {
+        draft.default = id;
+      },
+      update: (id, fn) => {
+        const defaults = Info.default(id);
+        const current = draft.agents.get(id) ?? {
+          ...defaults,
+          permissions: [...defaults.permissions, ...permissions]
+        };
+        if (!draft.agents.has(id))
+          draft.agents.set(id, current);
+        fn(current);
+        current.id = id;
+      },
+      remove: (id) => {
+        draft.agents.delete(id);
+      }
+    }),
+    finalize: () => bus.publish(Agent.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const selectable = (agent) => agent && agent.mode !== "subagent" && !agent.hidden ? agent : undefined;
+  const selectedDefault = () => {
+    const data = state.get();
+    const configured = data.default ? selectable(data.agents.get(data.default)) : undefined;
+    if (configured)
+      return configured;
+    const build = selectable(data.agents.get(ID.make("build")));
+    if (build)
+      return build;
+    for (const agent of data.agents.values()) {
+      const fallback = selectable(agent);
+      if (fallback)
+        return fallback;
+    }
+  };
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Agent.get")(function* (id) {
+      return state.get().agents.get(id);
+    }),
+    resolve: Effect.fn("Agent.resolve")(function* (id) {
+      if (id !== undefined)
+        return state.get().agents.get(ID.make(id));
+      return selectedDefault();
+    }),
+    select: Effect.fn("Agent.select")(function* (id) {
+      if (id !== undefined) {
+        const selected = ID.make(id);
+        return { id: selected, info: state.get().agents.get(selected) };
+      }
+      const info = selectedDefault();
+      return { id: info?.id ?? defaultID, info };
+    }),
+    list: Effect.fn("Agent.list")(function* () {
+      const agents = Array.fromIterable(state.get().agents.values());
+      const selected = selectedDefault();
+      if (!selected)
+        return agents;
+      return [selected, ...agents.filter((agent) => agent.id !== selected.id)];
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node, Global.node] });
+
+export { ID, Name, defaultID, Color, Info, Service, node, exports_agent, Event };

package/dist/chunks/ripgrep-4qzvx3fn.js

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

package/dist/chunks/ripgrep-4s2xwh5d.js

@@ -0,0 +1,91 @@
+import {
+  exports_permission
+} from "./ripgrep-v9bfv94f.js";
+import {
+  PositiveInt
+} from "./ripgrep-j07kk359.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/v1/config/agent.ts
+var exports_agent = {};
+__export(exports_agent, {
+  Info: () => Info,
+  ConfigAgentV1: () => exports_agent
+});
+import { Schema, SchemaGetter } from "effect";
+var Color = Schema.Union([
+  Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+  Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"])
+]);
+var AgentSchema = Schema.StructWithRest(Schema.Struct({
+  model: Schema.optional(Schema.String),
+  variant: Schema.optional(Schema.String).annotate({
+    description: "Default model variant for this agent (applies only when using the agent's configured model)."
+  }),
+  temperature: Schema.optional(Schema.Finite),
+  top_p: Schema.optional(Schema.Finite),
+  prompt: Schema.optional(Schema.String),
+  tools: Schema.optional(Schema.Record(Schema.String, Schema.Boolean)).annotate({
+    description: "@deprecated Use 'permission' field instead"
+  }),
+  disable: Schema.optional(Schema.Boolean),
+  description: Schema.optional(Schema.String).annotate({ description: "Description of when to use the agent" }),
+  mode: Schema.optional(Schema.Literals(["subagent", "primary", "all"])),
+  hidden: Schema.optional(Schema.Boolean).annotate({
+    description: "Hide this subagent from the @ autocomplete menu (default: false, only applies to mode: subagent)"
+  }),
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
+  color: Schema.optional(Color).annotate({
+    description: "Hex color code (e.g., #FF5733) or theme color (e.g., primary)"
+  }),
+  steps: Schema.optional(PositiveInt).annotate({
+    description: "Maximum number of agentic iterations before forcing text-only response"
+  }),
+  maxSteps: Schema.optional(PositiveInt).annotate({ description: "@deprecated Use 'steps' field instead." }),
+  permission: Schema.optional(exports_permission.Info)
+}), [Schema.Record(Schema.String, Schema.Any)]);
+var KNOWN_KEYS = new Set([
+  "name",
+  "model",
+  "variant",
+  "prompt",
+  "description",
+  "temperature",
+  "top_p",
+  "mode",
+  "hidden",
+  "color",
+  "steps",
+  "maxSteps",
+  "options",
+  "permission",
+  "disable",
+  "tools"
+]);
+var normalize = (agent) => {
+  const options = { ...agent.options };
+  for (const [key, value] of Object.entries(agent)) {
+    if (!KNOWN_KEYS.has(key))
+      options[key] = value;
+  }
+  const permission = {};
+  for (const [tool, enabled] of Object.entries(agent.tools ?? {})) {
+    const action = enabled ? "allow" : "deny";
+    if (tool === "write" || tool === "edit" || tool === "patch") {
+      permission.edit = action;
+      continue;
+    }
+    permission[tool] = action;
+  }
+  globalThis.Object.assign(permission, agent.permission);
+  const steps = agent.steps ?? agent.maxSteps;
+  return { ...agent, options, permission, ...steps !== undefined ? { steps } : {} };
+};
+var Info = AgentSchema.pipe(Schema.decodeTo(AgentSchema, {
+  decode: SchemaGetter.transform(normalize),
+  encode: SchemaGetter.passthrough({ strict: false })
+})).annotate({ identifier: "AgentConfig" });
+
+export { Info, exports_agent };