@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-8714cnrq.js

@@ -0,0 +1,486 @@
+import {
+  exports_usage
+} from "./location-mutation-8ywqk2j9.js";
+import {
+  SessionEvent
+} from "./location-mutation-a83yvq99.js";
+
+// src/session/runner/publish-llm-event.ts
+import { Clock, Effect } from "effect";
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : { value };
+var nonEmpty = (content) => content.length > 0 ? content : undefined;
+var stringify = (value) => {
+  if (typeof value === "string")
+    return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var hostedContent = (result) => {
+  if (result.type === "content") {
+    const content = nonEmpty(result.value);
+    if (content !== undefined)
+      return content;
+  }
+  return [{ type: "text", text: stringify(result.value) }];
+};
+var createLLMEventPublisher = (bus, input) => {
+  const deltaBatchInterval = 100;
+  const tools = new Map;
+  const failureSnapshot = (tool, metadata) => {
+    if (tool.progress === undefined)
+      return metadata === undefined ? {} : { metadata };
+    if (metadata === undefined)
+      return { metadata: tool.progress };
+    return { metadata: { ...tool.progress, ...metadata } };
+  };
+  const assistantMessageID = input.assistantMessageID;
+  let stepStarted = false;
+  let stepFailed = false;
+  let providerFailed = false;
+  let outputStarted = false;
+  let stepFailure;
+  let stepSettlement;
+  const startAssistant = Effect.fnUntraced(function* () {
+    if (stepStarted)
+      return assistantMessageID;
+    stepStarted = true;
+    yield* bus.publish(SessionEvent.Step.Started, {
+      sessionID: input.sessionID,
+      agent: input.agent,
+      model: input.model,
+      assistantMessageID,
+      snapshot: input.snapshot
+    });
+    return assistantMessageID;
+  });
+  const currentAssistantMessageID = () => stepStarted ? Effect.succeed(assistantMessageID) : Effect.die(new Error("Tool event before assistant step start"));
+  const providerState = (metadata) => metadata?.[input.providerMetadataKey];
+  const fragments = (name, ended, delta, single = false) => {
+    const chunks = new Map;
+    let nextOrdinal = 0;
+    const start = (id, state) => Effect.suspend(() => {
+      if (chunks.has(id))
+        return Effect.die(new Error(`Duplicate ${name} start: ${id}`));
+      if (single && chunks.size > 0)
+        return Effect.die(new Error(`${name} start before end: ${id}`));
+      const ordinal = nextOrdinal++;
+      chunks.set(id, { ordinal, values: [], pending: "", state });
+      return Effect.succeed(ordinal);
+    });
+    const publishDelta = Effect.fnUntraced(function* (id, force = false) {
+      if (!delta)
+        return;
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} delta before start: ${id}`));
+      if (!current.pending)
+        return;
+      const now = yield* Clock.currentTimeMillis;
+      if (!force && current.publishedAt !== undefined && now - current.publishedAt < deltaBatchInterval)
+        return;
+      yield* delta(id, current.pending, current.ordinal);
+      current.pending = "";
+      current.publishedAt = now;
+      return;
+    });
+    const append = Effect.fnUntraced(function* (id, value, state) {
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} delta before start: ${id}`));
+      current.values.push(value);
+      if (delta)
+        current.pending += value;
+      if (state !== undefined)
+        current.state = { ...current.state, ...state };
+      yield* publishDelta(id);
+      return current.ordinal;
+    });
+    const end = Effect.fnUntraced(function* (id, state, value) {
+      const current = chunks.get(id);
+      if (!current)
+        return yield* Effect.die(new Error(`${name} end before start: ${id}`));
+      yield* publishDelta(id, true);
+      yield* ended(id, value ?? current.values.join(""), current.ordinal, state === undefined ? current.state : { ...current.state, ...state });
+      chunks.delete(id);
+      return;
+    });
+    const flush2 = Effect.fnUntraced(function* () {
+      for (const id of Array.from(chunks.keys()))
+        yield* end(id);
+    });
+    return { start, append, end, flush: flush2, has: (id) => chunks.has(id) };
+  };
+  const text = fragments("text", (_textID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Text.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), (_textID, value, ordinal) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Text.Delta, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      delta: value
+    });
+  }), true);
+  const reasoning = fragments("reasoning", (_reasoningID, value, ordinal, state) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Reasoning.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      text: value,
+      state
+    });
+  }), (_reasoningID, value, ordinal) => Effect.gen(function* () {
+    yield* bus.publish(SessionEvent.Reasoning.Delta, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* currentAssistantMessageID(),
+      ordinal,
+      delta: value
+    });
+  }), true);
+  const toolInput = fragments("tool input", (id, value) => Effect.gen(function* () {
+    const tool = tools.get(id);
+    if (!tool)
+      return yield* Effect.die(new Error(`Tool input end before start: ${id}`));
+    yield* bus.publish(SessionEvent.Tool.Input.Ended, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      text: value
+    });
+  }));
+  const flushFragments = Effect.fnUntraced(function* () {
+    yield* text.flush();
+    yield* reasoning.flush();
+    yield* toolInput.flush();
+  });
+  const startToolInput = Effect.fnUntraced(function* (event) {
+    if (tools.has(event.id))
+      return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`));
+    const assistantMessageID2 = yield* startAssistant();
+    tools.set(event.id, {
+      assistantMessageID: assistantMessageID2,
+      name: event.name,
+      called: false,
+      settled: false,
+      providerExecuted: event.providerExecuted === true
+    });
+    yield* toolInput.start(event.id);
+    yield* bus.publish(SessionEvent.Tool.Input.Started, {
+      sessionID: input.sessionID,
+      assistantMessageID: assistantMessageID2,
+      id: event.id,
+      name: event.name
+    });
+  });
+  const endToolInput = Effect.fnUntraced(function* (event, value) {
+    const tool = tools.get(event.id);
+    if (!tool)
+      return yield* Effect.die(new Error(`Tool input end before start: ${event.id}`));
+    if (tool.name !== event.name)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+    if (!toolInput.has(event.id))
+      return yield* Effect.die(new Error(`Duplicate tool input end: ${event.id}`));
+    yield* toolInput.end(event.id, undefined, value);
+  });
+  const failMalformedToolInput = Effect.fnUntraced(function* (event) {
+    if (!tools.has(event.id))
+      yield* startToolInput(event);
+    const tool = tools.get(event.id);
+    if (!tool || tool.called || tool.settled)
+      return yield* Effect.die(new Error(`Malformed tool input after call settlement: ${event.id}`));
+    if (tool.name !== event.name)
+      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+    if (toolInput.has(event.id))
+      yield* endToolInput(event, event.raw);
+    tool.settled = true;
+    yield* bus.publish(SessionEvent.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id: event.id,
+      error: {
+        type: "tool.input-json",
+        message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON."
+      },
+      ...failureSnapshot(tool),
+      executed: false
+    });
+  });
+  const flush = Effect.fn("SessionRunner.flush")(function* () {
+    yield* flushFragments();
+  });
+  const failTool = Effect.fnUntraced(function* (id, error, metadata) {
+    const tool = tools.get(id);
+    if (!tool || tool.settled)
+      return false;
+    tool.settled = true;
+    yield* bus.publish(SessionEvent.Tool.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      error,
+      ...failureSnapshot(tool, metadata),
+      executed: tool.providerExecuted
+    });
+    return true;
+  });
+  const failTools = Effect.fnUntraced(function* (error, mode) {
+    let failed = false;
+    for (const [id, tool] of tools) {
+      if (tool.settled || mode === "hosted" && !tool.providerExecuted || mode === "uncalled" && tool.called)
+        continue;
+      failed = (yield* failTool(id, error)) || failed;
+    }
+    return failed;
+  });
+  const failAssistant = Effect.fnUntraced(function* (error) {
+    yield* flush();
+    yield* failTools(error, "uncalled");
+    yield* startAssistant();
+    if (stepFailure === undefined)
+      stepFailure = error;
+  });
+  const publishStepFailure = Effect.fnUntraced(function* (details) {
+    if (stepFailed || stepFailure === undefined)
+      return;
+    const assistantMessageID2 = yield* startAssistant();
+    stepFailed = true;
+    yield* bus.publish(SessionEvent.Step.Failed, {
+      sessionID: input.sessionID,
+      assistantMessageID: assistantMessageID2,
+      error: stepFailure,
+      ...details
+    });
+  });
+  const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")(function* (error, scope = "all") {
+    return yield* failTools(error, scope);
+  });
+  const assistantMessageIDForTool = (id) => {
+    const tool = tools.get(id);
+    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${id}`));
+  };
+  const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (event) {
+    switch (event.type) {
+      case "step-start":
+        yield* startAssistant();
+        return;
+      case "text-start":
+        outputStarted = true;
+        const startedTextOrdinal = yield* text.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Text.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedTextOrdinal
+        });
+        return;
+      case "text-delta":
+        yield* text.append(event.id, event.text, providerState(event.providerMetadata));
+        return;
+      case "text-end":
+        yield* text.end(event.id, providerState(event.providerMetadata));
+        return;
+      case "reasoning-start":
+        outputStarted = true;
+        const startedReasoningOrdinal = yield* reasoning.start(event.id, providerState(event.providerMetadata));
+        yield* bus.publish(SessionEvent.Reasoning.Started, {
+          sessionID: input.sessionID,
+          assistantMessageID: yield* startAssistant(),
+          ordinal: startedReasoningOrdinal,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      case "reasoning-delta":
+        yield* reasoning.append(event.id, event.text, providerState(event.providerMetadata));
+        return;
+      case "reasoning-end":
+        yield* reasoning.end(event.id, providerState(event.providerMetadata));
+        return;
+      case "tool-input-start":
+        outputStarted = true;
+        yield* startToolInput(event);
+        return;
+      case "tool-input-delta": {
+        const tool = tools.get(event.id);
+        if (!tool)
+          return yield* Effect.die(new Error(`Tool input delta before start: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (!toolInput.has(event.id))
+          return yield* Effect.die(new Error(`Tool input delta after end: ${event.id}`));
+        yield* toolInput.append(event.id, event.text);
+        return;
+      }
+      case "tool-input-end":
+        yield* endToolInput(event);
+        return;
+      case "tool-input-error":
+        outputStarted = true;
+        yield* failMalformedToolInput(event);
+        return;
+      case "tool-call": {
+        outputStarted = true;
+        if (!tools.has(event.id))
+          yield* startToolInput(event);
+        const tool = tools.get(event.id);
+        if (toolInput.has(event.id))
+          yield* endToolInput(event);
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool call name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.called)
+          return yield* Effect.die(new Error(`Duplicate tool call: ${event.id}`));
+        tool.called = true;
+        tool.providerExecuted = event.providerExecuted === true;
+        yield* bus.publish(SessionEvent.Tool.Called, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          input: asRecord(event.input),
+          executed: tool.providerExecuted,
+          state: providerState(event.providerMetadata)
+        });
+        return;
+      }
+      case "tool-result": {
+        const tool = tools.get(event.id);
+        if (!tool?.called)
+          return yield* Effect.die(new Error(`Tool result before call: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool result name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.settled) {
+          if (event.result.type === "error")
+            return;
+          return yield* Effect.die(new Error(`Duplicate tool result: ${event.id}`));
+        }
+        tool.settled = true;
+        const executed = event.providerExecuted === true || tool.providerExecuted;
+        const resultState = providerState(event.providerMetadata);
+        if (event.result.type === "error") {
+          yield* bus.publish(SessionEvent.Tool.Failed, {
+            sessionID: input.sessionID,
+            assistantMessageID: tool.assistantMessageID,
+            id: event.id,
+            error: { type: "tool.execution", message: stringify(event.result.value) },
+            ...failureSnapshot(tool),
+            executed,
+            resultState
+          });
+          return;
+        }
+        yield* bus.publish(SessionEvent.Tool.Success, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          content: hostedContent(event.result),
+          executed,
+          resultState
+        });
+        return;
+      }
+      case "tool-error": {
+        const tool = tools.get(event.id);
+        if (!tool?.called)
+          return yield* Effect.die(new Error(`Tool error before call: ${event.id}`));
+        if (tool.name !== event.name)
+          return yield* Effect.die(new Error(`Tool error name changed for ${event.id}: ${tool.name} -> ${event.name}`));
+        if (tool.settled)
+          return yield* Effect.die(new Error(`Duplicate tool error: ${event.id}`));
+        tool.settled = true;
+        yield* bus.publish(SessionEvent.Tool.Failed, {
+          sessionID: input.sessionID,
+          assistantMessageID: tool.assistantMessageID,
+          id: event.id,
+          error: event.message === `Unknown tool: ${event.name}` ? { type: "tool.unknown", message: event.message } : { type: "tool.execution", message: event.message },
+          ...failureSnapshot(tool),
+          executed: tool.providerExecuted,
+          resultState: providerState(event.providerMetadata)
+        });
+        return;
+      }
+      case "step-finish":
+        yield* flush();
+        if (stepSettlement)
+          return yield* Effect.die(new Error("Duplicate step finish"));
+        stepSettlement = { finish: event.reason.normalized, tokens: exports_usage.tokens(event.usage) };
+        if (event.reason.normalized === "content-filter") {
+          providerFailed = true;
+          yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" });
+          return;
+        }
+        return;
+      case "finish":
+        return;
+      case "provider-error":
+        providerFailed = true;
+        yield* failAssistant({ type: "provider.unknown", message: event.message });
+        return;
+    }
+  });
+  const progress = Effect.fnUntraced(function* (id, update) {
+    const tool = tools.get(id);
+    if (!tool?.called || tool.settled)
+      return yield* Effect.die(new Error(`Tool progress outside running call: ${id}`));
+    tool.progress = update;
+    yield* bus.publish(SessionEvent.Tool.Progress, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      metadata: update
+    });
+  });
+  const toolExecution = Effect.fnUntraced(function* (id, name, result) {
+    const tool = tools.get(id);
+    if (!tool?.called)
+      return yield* Effect.die(new Error(`Tool execution before call: ${id}`));
+    if (tool.name !== name)
+      return yield* Effect.die(new Error(`Tool execution name changed for ${id}: ${tool.name} -> ${name}`));
+    if (tool.settled)
+      return yield* Effect.die(new Error(`Duplicate tool execution: ${id}`));
+    tool.settled = true;
+    const content = typeof result.content === "string" ? [{ type: "text", text: result.content }] : result.content === undefined ? [] : [...result.content];
+    if (content.length === 0)
+      return yield* Effect.die(new Error(`Tool execution has no content: ${id}`));
+    yield* bus.publish(SessionEvent.Tool.Success, {
+      sessionID: input.sessionID,
+      assistantMessageID: tool.assistantMessageID,
+      id,
+      content: [content[0], ...content.slice(1)],
+      ...result.metadata === undefined ? {} : { metadata: result.metadata },
+      executed: tool.providerExecuted
+    });
+  });
+  return {
+    publish,
+    progress,
+    toolExecution,
+    flush,
+    failAssistant,
+    failTool,
+    publishStepFailure,
+    failUnsettledTools,
+    hasProviderError: () => providerFailed,
+    record: () => ({
+      outputStarted,
+      providerFailed,
+      failure: stepFailure,
+      finish: stepSettlement,
+      calls: Array.from(tools, ([id, tool]) => ({
+        id,
+        name: tool.name,
+        called: tool.called,
+        settled: tool.settled,
+        providerExecuted: tool.providerExecuted
+      }))
+    }),
+    startAssistant,
+    assistantMessageID: assistantMessageIDForTool
+  };
+};
+
+export { createLLMEventPublisher };

package/dist/chunks/location-mutation-880b4y2j.js

@@ -0,0 +1,183 @@
+import {
+  exports_app
+} from "./location-mutation-50jxp3hw.js";
+import {
+  exports_integration
+} from "./location-mutation-67ww7a6n.js";
+import {
+  exports_credential
+} from "./location-mutation-xvc235nh.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 };