@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.161

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-q4g3afnw.js

@@ -0,0 +1,623 @@
+import {
+  ClientApi2
+} from "./service-probe-vmytr4q8.js";
+import {
+  ClientError2
+} from "./service-probe-y2etg5bs.js";
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/effect/generated/client.ts
+var exports_client2 = {};
+__export(exports_client2, {
+  make: () => make3
+});
+import { Effect, Stream, Schema } from "effect";
+import { Sse } from "effect/encoding";
+import { HttpClientError } from "effect/http";
+import { HttpApiClient } from "effect/http-api";
+var mapClientError = (error) => HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error) ? new ClientError2({ cause: error }) : error;
+var preserveEffect = () => (effect) => effect;
+var preserveStream = () => (stream) => stream;
+var EndpointServerInfo = (raw) => () => preserveEffect()(raw["server.info"]({}).pipe(Effect.mapError(mapClientError)));
+var EndpointServerPair = (raw) => () => preserveEffect()(raw["server.pair"]({}).pipe(Effect.mapError(mapClientError)));
+var EndpointServerConnect = (raw) => (input) => preserveEffect()(raw["server.connect"]({ params: { code: input["code"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupServer = (raw) => ({
+  info: EndpointServerInfo(raw),
+  pair: EndpointServerPair(raw),
+  connect: EndpointServerConnect(raw)
+});
+var EndpointLocationGet = (raw) => (input) => preserveEffect()(raw["location.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointLocationReload = (raw) => () => preserveEffect()(raw["location.reload"]({}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupLocation = (raw) => ({
+  get: EndpointLocationGet(raw),
+  reload: EndpointLocationReload(raw)
+});
+var EndpointAgentList = (raw) => (input) => preserveEffect()(raw["agent.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointAgentGet = (raw) => (input) => preserveEffect()(raw["agent.get"]({ params: { agentID: input["agentID"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupAgent = (raw) => ({
+  list: EndpointAgentList(raw),
+  get: EndpointAgentGet(raw)
+});
+var EndpointPluginList = (raw) => (input) => preserveEffect()(raw["plugin.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPluginCheck = (raw) => (input) => preserveEffect()(raw["plugin.check"]({ query: { location: input?.["location"] }, payload: { target: input?.["target"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPluginUpdate = (raw) => (input) => preserveEffect()(raw["plugin.update"]({ query: { location: input["location"] }, payload: { targets: input["targets"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupPlugin = (raw) => ({
+  list: EndpointPluginList(raw),
+  check: EndpointPluginCheck(raw),
+  update: EndpointPluginUpdate(raw)
+});
+var EndpointSessionList = (raw) => (input) => preserveEffect()(raw["session.list"]({
+  query: {
+    limit: input?.["limit"],
+    order: input?.["order"],
+    search: input?.["search"],
+    parentID: input?.["parentID"],
+    directory: input?.["directory"],
+    project: input?.["project"],
+    subpath: input?.["subpath"],
+    cursor: input?.["cursor"]
+  }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionStats = (raw) => (input) => preserveEffect()(raw["session.stats"]({
+  query: {
+    from: input?.["from"],
+    to: input?.["to"],
+    project: input?.["project"],
+    timezone: input?.["timezone"],
+    tools: input?.["tools"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionCreate = (raw) => (input) => preserveEffect()(raw["session.create"]({
+  payload: {
+    id: input?.["id"],
+    parentID: input?.["parentID"],
+    title: input?.["title"],
+    agent: input?.["agent"],
+    model: input?.["model"],
+    location: input?.["location"],
+    metadata: input?.["metadata"],
+    permissions: input?.["permissions"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionImport = (raw) => (input) => preserveEffect()(raw["session.import"]({
+  payload: { info: input["info"], messages: input["messages"], location: input["location"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionExport = (raw) => (input) => preserveEffect()(raw["session.export"]({ params: { sessionID: input["sessionID"] }, query: { sanitize: input["sanitize"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionActive = (raw) => () => preserveEffect()(raw["session.active"]({}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionGet = (raw) => (input) => preserveEffect()(raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionRemove = (raw) => (input) => preserveEffect()(raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionFork = (raw) => (input) => preserveEffect()(raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { before: input["before"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionSwitchAgent = (raw) => (input) => preserveEffect()(raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionSwitchModel = (raw) => (input) => preserveEffect()(raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionUpdate = (raw) => (input) => preserveEffect()(raw["session.update"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionMove = (raw) => (input) => preserveEffect()(raw["session.move"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { directory: input["directory"], delivery: input["delivery"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionPrompt = (raw) => (input) => preserveEffect()(raw["session.prompt"]({
+  params: { sessionID: input["sessionID"] },
+  payload: {
+    id: input["id"],
+    text: input["text"],
+    files: input["files"],
+    agents: input["agents"],
+    skills: input["skills"],
+    metadata: input["metadata"],
+    delivery: input["delivery"],
+    resume: input["resume"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionCommand = (raw) => (input) => preserveEffect()(raw["session.command"]({
+  params: { sessionID: input["sessionID"] },
+  payload: {
+    name: input["name"],
+    text: input["text"],
+    files: input["files"],
+    agents: input["agents"],
+    skills: input["skills"],
+    delivery: input["delivery"]
+  }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionSkill = (raw) => (input) => preserveEffect()(raw["session.skill"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { id: input["id"], resume: input["resume"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionSynthetic = (raw) => (input) => preserveEffect()(raw["session.synthetic"]({
+  params: { sessionID: input["sessionID"] },
+  payload: {
+    id: input["id"],
+    text: input["text"],
+    description: input["description"],
+    metadata: input["metadata"],
+    delivery: input["delivery"],
+    resume: input["resume"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionShell = (raw) => (input) => preserveEffect()(raw["session.shell"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { id: input["id"], command: input["command"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionCompact = (raw) => (input) => preserveEffect()(raw["session.compact"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { id: input["id"], delivery: input["delivery"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionWait = (raw) => (input) => preserveEffect()(raw["session.wait"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionRevertStage = (raw) => (input) => preserveEffect()(raw["session.revert.stage"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { messageID: input["messageID"], files: input["files"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionRevertClear = (raw) => (input) => preserveEffect()(raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionRevertCommit = (raw) => (input) => preserveEffect()(raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionContext = (raw) => (input) => preserveEffect()(raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionDiff = (raw) => (input) => preserveEffect()(raw["session.diff"]({
+  params: { sessionID: input["sessionID"] },
+  query: { from: input["from"], to: input["to"], context: input["context"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionInboxList = (raw) => (input) => preserveEffect()(raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionInboxCancel = (raw) => (input) => preserveEffect()(raw["session.inbox.cancel"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionInboxUpdate = (raw) => (input) => preserveEffect()(raw["session.inbox.update"]({
+  params: { sessionID: input["sessionID"], inboxID: input["inboxID"] },
+  payload: { delivery: input["delivery"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionInstructionsEntryList = (raw) => (input) => preserveEffect()(raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionInstructionsEntryPut = (raw) => (input) => preserveEffect()(raw["session.instructions.entry.put"]({
+  params: { sessionID: input["sessionID"], key: input["key"] },
+  payload: { value: input["value"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionInstructionsEntryRemove = (raw) => (input) => preserveEffect()(raw["session.instructions.entry.remove"]({ params: { sessionID: input["sessionID"], key: input["key"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionGenerate = (raw) => (input) => preserveEffect()(raw["session.generate"]({ params: { sessionID: input["sessionID"] }, payload: { prompt: input["prompt"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionLog = (raw) => (input) => preserveStream()(Stream.unwrap(raw["session.log"]({
+  params: { sessionID: input["sessionID"] },
+  query: { after: input["after"], follow: input["follow"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))))));
+var EndpointSessionInterrupt = (raw) => (input) => preserveEffect()(raw["session.interrupt"]({ params: { sessionID: input["sessionID"] }, query: { resume: input["resume"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionBackground = (raw) => (input) => preserveEffect()(raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionMessageGet = (raw) => (input) => preserveEffect()(raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionFormList = (raw) => (input) => preserveEffect()(raw["session.form.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionFormCreate = (raw) => (input) => preserveEffect()(raw["session.form.create"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionFormGet = (raw) => (input) => preserveEffect()(raw["session.form.get"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointSessionFormReply = (raw) => (input) => preserveEffect()(raw["session.form.reply"]({
+  params: { sessionID: input["sessionID"], formID: input["formID"] },
+  payload: { answer: input["answer"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionFormCancel = (raw) => (input) => preserveEffect()(raw["session.form.cancel"]({
+  params: { sessionID: input["sessionID"], formID: input["formID"] },
+  query: { message: input["message"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionEnvironment = (raw) => (input) => preserveEffect()(raw["session.environment"]({
+  params: { sessionID: input["sessionID"] },
+  payload: { variables: input["variables"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointSessionView = (raw) => (input) => preserveEffect()(raw["session.view"]({ params: { sessionID: input["sessionID"] }, payload: { idle: input["idle"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupSession = (raw) => ({
+  list: EndpointSessionList(raw),
+  stats: EndpointSessionStats(raw),
+  create: EndpointSessionCreate(raw),
+  import: EndpointSessionImport(raw),
+  export: EndpointSessionExport(raw),
+  active: EndpointSessionActive(raw),
+  get: EndpointSessionGet(raw),
+  remove: EndpointSessionRemove(raw),
+  fork: EndpointSessionFork(raw),
+  switchAgent: EndpointSessionSwitchAgent(raw),
+  switchModel: EndpointSessionSwitchModel(raw),
+  update: EndpointSessionUpdate(raw),
+  move: EndpointSessionMove(raw),
+  prompt: EndpointSessionPrompt(raw),
+  command: EndpointSessionCommand(raw),
+  skill: EndpointSessionSkill(raw),
+  synthetic: EndpointSessionSynthetic(raw),
+  shell: EndpointSessionShell(raw),
+  compact: EndpointSessionCompact(raw),
+  wait: EndpointSessionWait(raw),
+  revert: {
+    stage: EndpointSessionRevertStage(raw),
+    clear: EndpointSessionRevertClear(raw),
+    commit: EndpointSessionRevertCommit(raw)
+  },
+  context: EndpointSessionContext(raw),
+  diff: EndpointSessionDiff(raw),
+  inbox: {
+    list: EndpointSessionInboxList(raw),
+    cancel: EndpointSessionInboxCancel(raw),
+    update: EndpointSessionInboxUpdate(raw)
+  },
+  instructions: {
+    entry: {
+      list: EndpointSessionInstructionsEntryList(raw),
+      put: EndpointSessionInstructionsEntryPut(raw),
+      remove: EndpointSessionInstructionsEntryRemove(raw)
+    }
+  },
+  generate: EndpointSessionGenerate(raw),
+  log: EndpointSessionLog(raw),
+  interrupt: EndpointSessionInterrupt(raw),
+  background: EndpointSessionBackground(raw),
+  message: { get: EndpointSessionMessageGet(raw) },
+  form: {
+    list: EndpointSessionFormList(raw),
+    create: EndpointSessionFormCreate(raw),
+    get: EndpointSessionFormGet(raw),
+    reply: EndpointSessionFormReply(raw),
+    cancel: EndpointSessionFormCancel(raw)
+  },
+  environment: EndpointSessionEnvironment(raw),
+  view: EndpointSessionView(raw)
+});
+var EndpointMessageList = (raw) => (input) => preserveEffect()(raw["session.messages"]({
+  params: { sessionID: input["sessionID"] },
+  query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupMessage = (raw) => ({ list: EndpointMessageList(raw) });
+var EndpointModelList = (raw) => (input) => preserveEffect()(raw["model.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointModelDefault = (raw) => (input) => preserveEffect()(raw["model.default"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupModel = (raw) => ({
+  list: EndpointModelList(raw),
+  default: EndpointModelDefault(raw)
+});
+var EndpointGenerateText = (raw) => (input) => preserveEffect()(raw["generate.text"]({ payload: { prompt: input["prompt"], model: input["model"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var adaptGroupGenerate = (raw) => ({ text: EndpointGenerateText(raw) });
+var EndpointProviderList = (raw) => (input) => preserveEffect()(raw["provider.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointProviderGet = (raw) => (input) => preserveEffect()(raw["provider.get"]({ params: { providerID: input["providerID"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupProvider = (raw) => ({
+  list: EndpointProviderList(raw),
+  get: EndpointProviderGet(raw)
+});
+var EndpointIntegrationList = (raw) => (input) => preserveEffect()(raw["integration.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationGet = (raw) => (input) => preserveEffect()(raw["integration.get"]({
+  params: { integrationID: input["integrationID"] },
+  query: { location: input["location"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationWellknownAdd = (raw) => (input) => preserveEffect()(raw["integration.wellknown.add"]({ query: { location: input["location"] }, payload: { url: input["url"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationConnectKey = (raw) => (input) => preserveEffect()(raw["integration.connect.key"]({
+  params: { integrationID: input["integrationID"] },
+  query: { location: input["location"] },
+  payload: { key: input["key"], answer: input["answer"], label: input["label"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationConnectExternal = (raw) => (input) => preserveEffect()(raw["integration.connect.external"]({
+  params: { integrationID: input["integrationID"] },
+  query: { location: input["location"] },
+  payload: { methodID: input["methodID"], answer: input["answer"], label: input["label"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationOauthConnect = (raw) => (input) => preserveEffect()(raw["integration.oauth.connect"]({
+  params: { integrationID: input["integrationID"] },
+  query: { location: input["location"] },
+  payload: { methodID: input["methodID"], answer: input["answer"], label: input["label"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationOauthStatus = (raw) => (input) => preserveEffect()(raw["integration.oauth.status"]({
+  params: { integrationID: input["integrationID"], attemptID: input["attemptID"] },
+  query: { location: input["location"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationOauthComplete = (raw) => (input) => preserveEffect()(raw["integration.oauth.complete"]({
+  params: { integrationID: input["integrationID"], attemptID: input["attemptID"] },
+  query: { location: input["location"] },
+  payload: { code: input["code"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationOauthCancel = (raw) => (input) => preserveEffect()(raw["integration.oauth.cancel"]({
+  params: { integrationID: input["integrationID"], attemptID: input["attemptID"] },
+  query: { location: input["location"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationCommandConnect = (raw) => (input) => preserveEffect()(raw["integration.command.connect"]({
+  params: { integrationID: input["integrationID"] },
+  query: { location: input["location"] },
+  payload: { methodID: input["methodID"], label: input["label"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationCommandStatus = (raw) => (input) => preserveEffect()(raw["integration.command.status"]({
+  params: { integrationID: input["integrationID"], attemptID: input["attemptID"] },
+  query: { location: input["location"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointIntegrationCommandCancel = (raw) => (input) => preserveEffect()(raw["integration.command.cancel"]({
+  params: { integrationID: input["integrationID"], attemptID: input["attemptID"] },
+  query: { location: input["location"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupIntegration = (raw) => ({
+  list: EndpointIntegrationList(raw),
+  get: EndpointIntegrationGet(raw),
+  wellknown: { add: EndpointIntegrationWellknownAdd(raw) },
+  connect: { key: EndpointIntegrationConnectKey(raw), external: EndpointIntegrationConnectExternal(raw) },
+  oauth: {
+    connect: EndpointIntegrationOauthConnect(raw),
+    status: EndpointIntegrationOauthStatus(raw),
+    complete: EndpointIntegrationOauthComplete(raw),
+    cancel: EndpointIntegrationOauthCancel(raw)
+  },
+  command: {
+    connect: EndpointIntegrationCommandConnect(raw),
+    status: EndpointIntegrationCommandStatus(raw),
+    cancel: EndpointIntegrationCommandCancel(raw)
+  }
+});
+var EndpointMcpList = (raw) => (input) => preserveEffect()(raw["mcp.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointMcpAdd = (raw) => (input) => preserveEffect()(raw["mcp.add"]({
+  params: { server: input["server"] },
+  query: { location: input["location"] },
+  payload: { config: input["config"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointMcpRemove = (raw) => (input) => preserveEffect()(raw["mcp.remove"]({ params: { server: input["server"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointMcpConnect = (raw) => (input) => preserveEffect()(raw["mcp.connect"]({ params: { server: input["server"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointMcpDisconnect = (raw) => (input) => preserveEffect()(raw["mcp.disconnect"]({ params: { server: input["server"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointMcpResourceCatalog = (raw) => (input) => preserveEffect()(raw["mcp.resource.catalog"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupMcp = (raw) => ({
+  list: EndpointMcpList(raw),
+  add: EndpointMcpAdd(raw),
+  remove: EndpointMcpRemove(raw),
+  connect: EndpointMcpConnect(raw),
+  disconnect: EndpointMcpDisconnect(raw),
+  resource: { catalog: EndpointMcpResourceCatalog(raw) }
+});
+var EndpointCredentialList = (raw) => () => preserveEffect()(raw["credential.list"]({}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointCredentialCreate = (raw) => (input) => preserveEffect()(raw["credential.create"]({
+  payload: {
+    id: input["id"],
+    integrationID: input["integrationID"],
+    label: input["label"],
+    value: input["value"],
+    activate: input["activate"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointCredentialUpdate = (raw) => (input) => preserveEffect()(raw["credential.update"]({
+  params: { credentialID: input["credentialID"] },
+  payload: { label: input["label"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointCredentialActivate = (raw) => (input) => preserveEffect()(raw["credential.activate"]({ params: { credentialID: input["credentialID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointCredentialRemove = (raw) => (input) => preserveEffect()(raw["credential.remove"]({ params: { credentialID: input["credentialID"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupCredential = (raw) => ({
+  list: EndpointCredentialList(raw),
+  create: EndpointCredentialCreate(raw),
+  update: EndpointCredentialUpdate(raw),
+  activate: EndpointCredentialActivate(raw),
+  remove: EndpointCredentialRemove(raw)
+});
+var EndpointProjectList = (raw) => (input) => preserveEffect()(raw["project.list"]({ query: { archived: input?.["archived"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointProjectUpdate = (raw) => (input) => preserveEffect()(raw["project.update"]({
+  params: { projectID: input["projectID"] },
+  payload: { canonical: input["canonical"], name: input["name"], icon: input["icon"], commands: input["commands"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupProject = (raw) => ({
+  list: EndpointProjectList(raw),
+  update: EndpointProjectUpdate(raw)
+});
+var EndpointFormList = (raw) => (input) => preserveEffect()(raw["form.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupForm = (raw) => ({ list: EndpointFormList(raw) });
+var EndpointPermissionRequestList = (raw) => (input) => preserveEffect()(raw["permission.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPermissionSavedList = (raw) => (input) => preserveEffect()(raw["permission.saved.list"]({ query: { projectID: input?.["projectID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointPermissionSavedRemove = (raw) => (input) => preserveEffect()(raw["permission.saved.remove"]({ params: { id: input["id"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPermissionCreate = (raw) => (input) => preserveEffect()(raw["session.permission.create"]({
+  params: { sessionID: input["sessionID"] },
+  payload: {
+    id: input["id"],
+    action: input["action"],
+    resources: input["resources"],
+    save: input["save"],
+    metadata: input["metadata"],
+    source: input["source"],
+    agent: input["agent"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointPermissionList = (raw) => (input) => preserveEffect()(raw["session.permission.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointPermissionGet = (raw) => (input) => preserveEffect()(raw["session.permission.get"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointPermissionReply = (raw) => (input) => preserveEffect()(raw["session.permission.reply"]({
+  params: { sessionID: input["sessionID"], requestID: input["requestID"] },
+  payload: { decision: input["decision"], message: input["message"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupPermission = (raw) => ({
+  request: { list: EndpointPermissionRequestList(raw) },
+  saved: { list: EndpointPermissionSavedList(raw), remove: EndpointPermissionSavedRemove(raw) },
+  create: EndpointPermissionCreate(raw),
+  list: EndpointPermissionList(raw),
+  get: EndpointPermissionGet(raw),
+  reply: EndpointPermissionReply(raw)
+});
+var EndpointFileList = (raw) => (input) => preserveEffect()(raw["fs.list"]({ query: { location: input?.["location"], path: input?.["path"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointFileFind = (raw) => (input) => preserveEffect()(raw["fs.find"]({
+  query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupFile = (raw) => ({ list: EndpointFileList(raw), find: EndpointFileFind(raw) });
+var EndpointCommandList = (raw) => (input) => preserveEffect()(raw["command.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupCommand = (raw) => ({ list: EndpointCommandList(raw) });
+var EndpointSkillList = (raw) => (input) => preserveEffect()(raw["skill.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupSkill = (raw) => ({ list: EndpointSkillList(raw) });
+var EndpointRpcCall = (raw) => (input) => preserveEffect()(raw["rpc.call"]({
+  params: { rpcID: input["rpcID"], method: input["method"] },
+  query: { location: input["location"] },
+  payload: { input: input["input"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupRpc = (raw) => ({ call: EndpointRpcCall(raw) });
+var EndpointEventSubscribe = (raw) => () => preserveStream()(Stream.unwrap(raw["event.subscribe"]({}).pipe(Effect.mapError(mapClientError), Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))))));
+var adaptGroupEvent = (raw) => ({ subscribe: EndpointEventSubscribe(raw) });
+var EndpointPtyList = (raw) => (input) => preserveEffect()(raw["pty.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPtyCreate = (raw) => (input) => preserveEffect()(raw["pty.create"]({
+  query: { location: input?.["location"] },
+  payload: {
+    command: input?.["command"],
+    args: input?.["args"],
+    cwd: input?.["cwd"],
+    title: input?.["title"],
+    env: input?.["env"]
+  }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointPtyGet = (raw) => (input) => preserveEffect()(raw["pty.get"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPtyUpdate = (raw) => (input) => preserveEffect()(raw["pty.update"]({
+  params: { ptyID: input["ptyID"] },
+  query: { location: input["location"] },
+  payload: { title: input["title"], size: input["size"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointPtyRemove = (raw) => (input) => preserveEffect()(raw["pty.remove"]({ params: { ptyID: input["ptyID"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointPtyConnectToken = (raw) => (input) => preserveEffect()(raw["pty.connectToken"]({
+  params: { ptyID: input["ptyID"] },
+  query: { location: input["location"] },
+  headers: { "x-opencode-ticket": input["x-opencode-ticket"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupPty = (raw) => ({
+  list: EndpointPtyList(raw),
+  create: EndpointPtyCreate(raw),
+  get: EndpointPtyGet(raw),
+  update: EndpointPtyUpdate(raw),
+  remove: EndpointPtyRemove(raw),
+  connect: { token: EndpointPtyConnectToken(raw) }
+});
+var EndpointExperimentalPersistentPtyRead = (raw) => (input) => preserveEffect()(raw["persistentPty.read"]({ params: { sessionID: input["sessionID"] }, query: { lines: input["lines"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointExperimentalPersistentPtyList = (raw) => (input) => preserveEffect()(raw["persistentPty.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointExperimentalPersistentPtyCreate = (raw) => (input) => preserveEffect()(raw["persistentPty.create"]({
+  params: { sessionID: input["sessionID"] },
+  payload: {
+    command: input["command"],
+    args: input["args"],
+    cwd: input["cwd"],
+    title: input["title"],
+    env: input["env"],
+    size: input["size"]
+  }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointExperimentalPersistentPtyShutdown = (raw) => () => preserveEffect()(raw["persistentPty.shutdown"]({}).pipe(Effect.mapError(mapClientError)));
+var EndpointExperimentalPersistentPtyHandoff = (raw) => () => preserveEffect()(raw["persistentPty.handoff"]({}).pipe(Effect.mapError(mapClientError)));
+var EndpointExperimentalPersistentPtyGet = (raw) => (input) => preserveEffect()(raw["persistentPty.get"]({ params: { ptyID: input["ptyID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointExperimentalPersistentPtyUpdate = (raw) => (input) => preserveEffect()(raw["persistentPty.update"]({
+  params: { ptyID: input["ptyID"] },
+  payload: { attachmentID: input["attachmentID"], size: input["size"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointExperimentalPersistentPtySnapshot = (raw) => (input) => preserveEffect()(raw["persistentPty.snapshot"]({ params: { ptyID: input["ptyID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var EndpointExperimentalPersistentPtyRemove = (raw) => (input) => preserveEffect()(raw["persistentPty.remove"]({ params: { ptyID: input["ptyID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointExperimentalPersistentPtyConnectToken = (raw) => (input) => preserveEffect()(raw["persistentPty.connectToken"]({
+  params: { ptyID: input["ptyID"] },
+  headers: { "x-opencode-ticket": input["x-opencode-ticket"] }
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+var adaptGroupExperimental = (raw) => ({
+  persistentPty: {
+    read: EndpointExperimentalPersistentPtyRead(raw),
+    list: EndpointExperimentalPersistentPtyList(raw),
+    create: EndpointExperimentalPersistentPtyCreate(raw),
+    shutdown: EndpointExperimentalPersistentPtyShutdown(raw),
+    handoff: EndpointExperimentalPersistentPtyHandoff(raw),
+    get: EndpointExperimentalPersistentPtyGet(raw),
+    update: EndpointExperimentalPersistentPtyUpdate(raw),
+    snapshot: EndpointExperimentalPersistentPtySnapshot(raw),
+    remove: EndpointExperimentalPersistentPtyRemove(raw),
+    connectToken: EndpointExperimentalPersistentPtyConnectToken(raw)
+  }
+});
+var EndpointShellList = (raw) => (input) => preserveEffect()(raw["shell.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointShellCreate = (raw) => (input) => preserveEffect()(raw["shell.create"]({
+  query: { location: input["location"] },
+  payload: { command: input["command"], cwd: input["cwd"], timeout: input["timeout"], metadata: input["metadata"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointShellGet = (raw) => (input) => preserveEffect()(raw["shell.get"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointShellOutput = (raw) => (input) => preserveEffect()(raw["shell.output"]({
+  params: { id: input["id"] },
+  query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointShellRemove = (raw) => (input) => preserveEffect()(raw["shell.remove"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupShell = (raw) => ({
+  list: EndpointShellList(raw),
+  create: EndpointShellCreate(raw),
+  get: EndpointShellGet(raw),
+  output: EndpointShellOutput(raw),
+  remove: EndpointShellRemove(raw)
+});
+var EndpointReferenceList = (raw) => (input) => preserveEffect()(raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupReference = (raw) => ({ list: EndpointReferenceList(raw) });
+var EndpointWorktreeList = (raw) => (input) => preserveEffect()(raw["worktree.list"]({ query: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointWorktreeCreate = (raw) => (input) => preserveEffect()(raw["worktree.create"]({
+  payload: {
+    projectID: input["projectID"],
+    from: input["from"],
+    branch: input["branch"],
+    directory: input["directory"],
+    name: input["name"]
+  }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointWorktreeRemove = (raw) => (input) => preserveEffect()(raw["worktree.remove"]({
+  payload: { projectID: input["projectID"], directory: input["directory"], force: input["force"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointWorktreeRefresh = (raw) => (input) => preserveEffect()(raw["worktree.refresh"]({ payload: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupWorktree = (raw) => ({
+  list: EndpointWorktreeList(raw),
+  create: EndpointWorktreeCreate(raw),
+  remove: EndpointWorktreeRemove(raw),
+  refresh: EndpointWorktreeRefresh(raw)
+});
+var EndpointVcsInit = (raw) => (input) => preserveEffect()(raw["vcs.init"]({ query: { location: input?.["location"], provider: input?.["provider"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointVcsGet = (raw) => (input) => preserveEffect()(raw["vcs.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointVcsBase = (raw) => (input) => preserveEffect()(raw["vcs.base"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointVcsStatus = (raw) => (input) => preserveEffect()(raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointVcsBranchList = (raw) => (input) => preserveEffect()(raw["vcs.branch.list"]({
+  query: { location: input?.["location"], search: input?.["search"], limit: input?.["limit"] }
+}).pipe(Effect.mapError(mapClientError)));
+var EndpointVcsDiff = (raw) => (input) => preserveEffect()(raw["vcs.diff"]({
+  query: { location: input["location"], mode: input["mode"], base: input["base"], context: input["context"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupVcs = (raw) => ({
+  init: EndpointVcsInit(raw),
+  get: EndpointVcsGet(raw),
+  base: EndpointVcsBase(raw),
+  status: EndpointVcsStatus(raw),
+  branch: { list: EndpointVcsBranchList(raw) },
+  diff: EndpointVcsDiff(raw)
+});
+var EndpointDebugLocationList = (raw) => () => preserveEffect()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)));
+var EndpointDebugLocationEvict = (raw) => (input) => preserveEffect()(raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupDebug = (raw) => ({
+  location: { list: EndpointDebugLocationList(raw), evict: EndpointDebugLocationEvict(raw) }
+});
+var EndpointMigrationV1Status = (raw) => () => preserveEffect()(raw["migration.v1.status"]({}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupMigration = (raw) => ({ v1: { status: EndpointMigrationV1Status(raw) } });
+var EndpointWebsearchProviders = (raw) => (input) => preserveEffect()(raw["websearch.providers"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointWebsearchQuery = (raw) => (input) => preserveEffect()(raw["websearch.query"]({
+  query: { location: input["location"] },
+  payload: { query: input["query"], providerID: input["providerID"] }
+}).pipe(Effect.mapError(mapClientError)));
+var adaptGroupWebsearch = (raw) => ({
+  providers: EndpointWebsearchProviders(raw),
+  query: EndpointWebsearchQuery(raw)
+});
+var EndpointConfigGet = (raw) => (input) => preserveEffect()(raw["config.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+var EndpointConfigShells = (raw) => () => preserveEffect()(raw["config.shells"]({}).pipe(Effect.mapError(mapClientError)));
+var EndpointConfigUpdate = (raw) => (input) => preserveEffect()(raw["config.update"]({ payload: { shell: input["shell"] } }).pipe(Effect.mapError(mapClientError)));
+var adaptGroupConfig = (raw) => ({
+  get: EndpointConfigGet(raw),
+  shells: EndpointConfigShells(raw),
+  update: EndpointConfigUpdate(raw)
+});
+var adaptClient = (raw) => ({
+  server: adaptGroupServer(raw["server.server"]),
+  location: adaptGroupLocation(raw["server.location"]),
+  agent: adaptGroupAgent(raw["server.agent"]),
+  plugin: adaptGroupPlugin(raw["server.plugin"]),
+  session: adaptGroupSession(raw["server.session"]),
+  message: adaptGroupMessage(raw["server.message"]),
+  model: adaptGroupModel(raw["server.model"]),
+  generate: adaptGroupGenerate(raw["server.generate"]),
+  provider: adaptGroupProvider(raw["server.provider"]),
+  integration: adaptGroupIntegration(raw["server.integration"]),
+  mcp: adaptGroupMcp(raw["server.mcp"]),
+  credential: adaptGroupCredential(raw["server.credential"]),
+  project: adaptGroupProject(raw["server.project"]),
+  form: adaptGroupForm(raw["server.form"]),
+  permission: adaptGroupPermission(raw["server.permission"]),
+  file: adaptGroupFile(raw["server.fs"]),
+  command: adaptGroupCommand(raw["server.command"]),
+  skill: adaptGroupSkill(raw["server.skill"]),
+  rpc: adaptGroupRpc(raw["server.rpc"]),
+  event: adaptGroupEvent(raw["server.event"]),
+  pty: adaptGroupPty(raw["server.pty"]),
+  experimental: adaptGroupExperimental(raw["server.experimental"]),
+  shell: adaptGroupShell(raw["server.shell"]),
+  reference: adaptGroupReference(raw["server.reference"]),
+  worktree: adaptGroupWorktree(raw["server.worktree"]),
+  vcs: adaptGroupVcs(raw["server.vcs"]),
+  debug: adaptGroupDebug(raw["server.debug"]),
+  migration: adaptGroupMigration(raw["server.migration"]),
+  websearch: adaptGroupWebsearch(raw["server.websearch"]),
+  config: adaptGroupConfig(raw["server.config"])
+});
+var make3 = (options) => HttpApiClient.make(ClientApi2, options).pipe(Effect.map(adaptClient));
+
+export { make3, exports_client2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-sxt88q69.js

@@ -0,0 +1,12 @@
+// src/service-version.ts
+function matchesVersion2(version, options) {
+  if (options.version === undefined)
+    return true;
+  if (version === undefined)
+    return false;
+  if (typeof options.version === "function")
+    return options.version(version);
+  return version === options.version;
+}
+
+export { matchesVersion2 };