lmin/zmo-cli
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

add experimental provider auth HttpApi slice (#22389)

Browse Source
This commit is contained in:
Kit Langton
2026-04-15 22:07:42 -04:00
committed by GitHub
parent cce05c1665
commit 5eae926846
18 changed files with 122 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
packages/server/package.json
View File

@@ -1,30 +0,0 @@
{
"$schema": "https://json.schemastore.org/package.json",
"name": "@opencode-ai/server",
"version": "1.4.6",
"type": "module",
"license": "MIT",
"exports": {
".": "./src/index.ts",
"./openapi": "./src/openapi.ts",
"./definition": "./src/definition/index.ts",
"./definition/api": "./src/definition/api.ts",
"./definition/question": "./src/definition/question.ts",
"./api": "./src/api/index.ts",
"./api/question": "./src/api/question.ts"
},
"files": [
"dist"
],
"scripts": {
"typecheck": "tsgo --noEmit",
"build": "tsc"
},
"devDependencies": {
"@typescript/native-preview": "catalog:",
"typescript": "catalog:"
},
"dependencies": {
"effect": "catalog:"
}
}

2
packages/server/src/api/index.ts
View File

@@ -1,2 +0,0 @@
export { makeQuestionHandler } from "./question.js"
export type { QuestionOps } from "./question.js"

37
packages/server/src/api/question.ts
View File

@@ -1,37 +0,0 @@
import { Effect, Schema } from "effect"
import { HttpApiBuilder } from "effect/unstable/httpapi"
import { QuestionReply, QuestionRequest, questionApi } from "../definition/question.js"
export interface QuestionOps<R = never> {
readonly list: () => Effect.Effect<ReadonlyArray<unknown>, never, R>
readonly reply: (input: {
requestID: string
answers: Schema.Schema.Type<typeof QuestionReply>["answers"]
}) => Effect.Effect<void, never, R>
}
export const makeQuestionHandler = <R>(ops: QuestionOps<R>) =>
HttpApiBuilder.group(
questionApi,
"question",
Effect.fn("QuestionHttpApi.handlers")(function* (handlers) {
const decode = Schema.decodeUnknownSync(Schema.Array(QuestionRequest))
const list = Effect.fn("QuestionHttpApi.list")(function* () {
return decode(yield* ops.list())
})
const reply = Effect.fn("QuestionHttpApi.reply")(function* (ctx: {
params: { requestID: string }
payload: Schema.Schema.Type<typeof QuestionReply>
}) {
yield* ops.reply({
requestID: ctx.params.requestID,
answers: ctx.payload.answers,
})
return true
})
return handlers.handle("list", list).handle("reply", reply)
}),
)

12
packages/server/src/definition/api.ts
View File

@@ -1,12 +0,0 @@
import { HttpApi, OpenApi } from "effect/unstable/httpapi"
import { questionApi } from "./question.js"
export const api = HttpApi.make("opencode")
.addHttpApi(questionApi)
.annotateMerge(
OpenApi.annotations({
title: "opencode experimental HttpApi",
version: "0.0.1",
description: "Experimental HttpApi surface for selected instance routes.",
}),
)

2
packages/server/src/definition/index.ts
View File

@@ -1,2 +0,0 @@
export { api } from "./api.js"
export { questionApi, QuestionReply, QuestionRequest } from "./question.js"

94
packages/server/src/definition/question.ts
View File

@@ -1,94 +0,0 @@
import { Schema } from "effect"
import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
const root = "/experimental/httpapi/question"
// Temporary transport-local schemas until canonical question schemas move into packages/core.
export const QuestionID = Schema.String.annotate({ identifier: "QuestionID" })
export const SessionID = Schema.String.annotate({ identifier: "SessionID" })
export const MessageID = Schema.String.annotate({ identifier: "MessageID" })
export class QuestionOption extends Schema.Class<QuestionOption>("QuestionOption")({
label: Schema.String.annotate({
description: "Display text (1-5 words, concise)",
}),
description: Schema.String.annotate({
description: "Explanation of choice",
}),
}) {}
const base = {
question: Schema.String.annotate({
description: "Complete question",
}),
header: Schema.String.annotate({
description: "Very short label (max 30 chars)",
}),
options: Schema.Array(QuestionOption).annotate({
description: "Available choices",
}),
multiple: Schema.optional(Schema.Boolean).annotate({
description: "Allow selecting multiple choices",
}),
}
export class QuestionInfo extends Schema.Class<QuestionInfo>("QuestionInfo")({
...base,
custom: Schema.optional(Schema.Boolean).annotate({
description: "Allow typing a custom answer (default: true)",
}),
}) {}
export class QuestionTool extends Schema.Class<QuestionTool>("QuestionTool")({
messageID: MessageID,
callID: Schema.String,
}) {}
export class QuestionRequest extends Schema.Class<QuestionRequest>("QuestionRequest")({
id: QuestionID,
sessionID: SessionID,
questions: Schema.Array(QuestionInfo).annotate({
description: "Questions to ask",
}),
tool: Schema.optional(QuestionTool),
}) {}
export const QuestionAnswer = Schema.Array(Schema.String).annotate({ identifier: "QuestionAnswer" })
export class QuestionReply extends Schema.Class<QuestionReply>("QuestionReply")({
answers: Schema.Array(QuestionAnswer).annotate({
description: "User answers in order of questions (each answer is an array of selected labels)",
}),
}) {}
export const questionApi = HttpApi.make("question").add(
HttpApiGroup.make("question")
.add(
HttpApiEndpoint.get("list", root, {
success: Schema.Array(QuestionRequest),
}).annotateMerge(
OpenApi.annotations({
identifier: "question.list",
summary: "List pending questions",
description: "Get all pending question requests across all sessions.",
}),
),
HttpApiEndpoint.post("reply", `${root}/:requestID/reply`, {
params: { requestID: QuestionID },
payload: QuestionReply,
success: Schema.Boolean,
}).annotateMerge(
OpenApi.annotations({
identifier: "question.reply",
summary: "Reply to question request",
description: "Provide answers to a question request from the AI assistant.",
}),
),
)
.annotateMerge(
OpenApi.annotations({
title: "question",
description: "Experimental HttpApi question routes.",
}),
),
)

6
packages/server/src/index.ts
View File

@@ -1,6 +0,0 @@
export { openapi } from "./openapi.js"
export { makeQuestionHandler } from "./api/question.js"
export { api } from "./definition/api.js"
export { questionApi, QuestionReply, QuestionRequest } from "./definition/question.js"
export type { OpenApiSpec, ServerApi } from "./types.js"
export type { QuestionOps } from "./api/question.js"

5
packages/server/src/openapi.ts
View File

@@ -1,5 +0,0 @@
import { OpenApi } from "effect/unstable/httpapi"
import { api } from "./definition/api.js"
import type { OpenApiSpec } from "./types.js"
export const openapi = (): OpenApiSpec => OpenApi.fromApi(api)

5
packages/server/src/types.ts
View File

@@ -1,5 +0,0 @@
import type { HttpApi, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
export type ServerApi = HttpApi.HttpApi<string, HttpApiGroup.Any>
export type OpenApiSpec = OpenApi.OpenAPISpec

10
packages/server/sst-env.d.ts vendored
View File

@@ -1,10 +0,0 @@
/* This file is auto-generated by SST. Do not edit. */
/* tslint:disable */
/* eslint-disable */
/* deno-fmt-ignore-file */
/* biome-ignore-all lint: auto-generated */
/// <reference path="../../sst-env.d.ts" />
import "sst"
export {}

15
packages/server/tsconfig.json
View File

@@ -1,15 +0,0 @@
{
"$schema": "https://json.schemastore.org/tsconfig.json",
"compilerOptions": {
"target": "ES2022",
"rootDir": "src",
"outDir": "dist",
"module": "nodenext",
"declaration": true,
"moduleResolution": "nodenext",
"lib": ["es2022", "dom", "dom.iterable"],
"strict": true,
"skipLibCheck": true
},
"include": ["src"]
}