@runlith/tagma 0.0.0-stage → 0.2.3

package/adapter/metadata.d.ts

@@ -0,0 +1,179 @@
+/// <reference path="../types/node/index.d.ts" />
+/// <reference path="../host.d.ts" />
+import { Schema } from "effect";
+import type { TransportFailure } from "@runlith/tagma/internal/packages/agent/src/transcript/entries";
+import type { Usage } from "@runlith/llm/schema/events";
+import { type HarnessClaim, type HarnessProvenance } from "@runlith/tagma/adapter/harness";
+export type MetadataField = 'model' | 'effort' | 'title';
+declare const MetadataInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+    readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "MetadataInvalid";
+} & Readonly<A>;
+export declare class MetadataInvalid extends MetadataInvalid_base<{
+    readonly reason: 'malformed' | 'identity' | 'limit' | 'path' | 'changed' | 'terminal-unavailable';
+}> {
+}
+export type MetadataValue = {
+    readonly value: string;
+    readonly claim: HarnessClaim;
+    readonly turnId: string | null;
+};
+export type MetadataValues = {
+    readonly [K in MetadataField]: MetadataValue | null;
+};
+export declare const emptyValues: () => MetadataValues;
+export declare const metadataText: Schema.String;
+export declare const recordedValue: (value: string | null | undefined, turnId?: string | null) => MetadataValue | null;
+export declare const jsonValue: (text: string) => unknown;
+export declare const metadataDecode: <S extends Schema.ConstraintDecoder<unknown>>(schema: S) => (input: unknown) => S["Type"];
+export type MetadataFold<A> = {
+    readonly json?: true;
+    readonly empty: () => A;
+    line(value: A, text: string): A;
+    readonly missed?: (head: string) => readonly MetadataField[];
+};
+export type MetadataSession = {
+    readonly rootKey: string;
+    readonly cwd: string;
+    readonly transcriptPath?: string;
+    readonly exportPath?: string;
+    readonly storage: {
+        readonly entries: readonly {
+            readonly name: string;
+            readonly value: string;
+        }[];
+    };
+};
+export declare const storageHome: (input: MetadataSession, variable: string, folder: string) => string | null;
+export type MetadataScreen = {
+    readonly title: string;
+};
+type Sourced = {
+    readonly source: HarnessProvenance;
+    readonly fields: readonly MetadataField[];
+};
+export type MetadataLocation = Sourced & ({
+    readonly kind: 'file';
+    readonly root: string;
+    readonly path: string;
+    readonly fold: MetadataFold<MetadataValues>;
+    readonly computed?: true;
+} | {
+    readonly kind: 'index';
+    readonly root: string;
+    readonly path: string;
+    readonly parse: (text: string) => {
+        id: string;
+        title: string | null;
+    };
+} | {
+    readonly kind: 'terminal';
+    readonly cells: boolean;
+    readonly parse: (screen: MetadataScreen) => MetadataValue | null;
+} | {
+    readonly kind: 'command';
+    readonly program: string;
+    readonly args: readonly string[];
+    readonly parse: (text: string) => MetadataValue | null;
+} | {
+    readonly kind: 'unreadable';
+    readonly reason: string;
+} | {
+    readonly kind: 'unsupported';
+});
+export declare function fileSource(root: string | null, path: string | undefined, fold: MetadataFold<MetadataValues>, fields: Sourced['fields'], source?: HarnessProvenance, computed?: boolean): MetadataLocation;
+export type TranscriptSaid = {
+    readonly texts: readonly string[];
+    readonly typed: readonly string[];
+    readonly at: number | null;
+};
+export type TranscriptRequest = {
+    readonly id: string;
+    readonly usage: Usage;
+    readonly model: string | null;
+    readonly at: number | null;
+    readonly main: boolean;
+};
+export type TranscriptCompaction = {
+    readonly tokens: number | null;
+    readonly at: number | null;
+};
+export type TranscriptWords = {
+    readonly said: readonly TranscriptSaid[];
+    readonly requests: Map<string, TranscriptRequest>;
+    readonly compacted: TranscriptCompaction | null;
+};
+export declare const unsaid: () => TranscriptWords;
+export declare const stampMillis: (value: string | undefined) => number | null;
+export declare function userTexts(message: unknown): readonly string[];
+export declare function transcriptSaid(message: unknown, stamp: string | undefined): TranscriptSaid | null;
+export type WordsSource = {
+    readonly root: string | null;
+    readonly path: string | undefined;
+    readonly fold: MetadataFold<TranscriptWords>;
+};
+export type MetadataFieldSource = {
+    readonly source: HarnessProvenance;
+    readonly readable: boolean;
+} | null;
+export type TailEnd = {
+    readonly _tag: 'Completed';
+    readonly message: string | null;
+} | {
+    readonly _tag: 'Aborted';
+} | {
+    readonly _tag: 'Failed';
+    readonly reason: string;
+    readonly cause?: TransportFailure;
+} | {
+    readonly _tag: 'Open';
+};
+export type TailWindow = {
+    readonly since: number;
+    readonly offset: number | null;
+    readonly turn: string | null;
+};
+export type TailReader = {
+    readonly shape: 'lines' | 'document';
+    readonly window: 'time' | 'offset';
+    readonly grain: number;
+    readonly stampOf: (record: unknown) => number | null;
+    readonly records?: (document: unknown) => readonly unknown[];
+    readonly judge: (newestFirst: readonly unknown[], exhausted: boolean, turn: string | null) => TailEnd | null;
+};
+export type TailLocation = {
+    readonly root: string;
+    readonly path: string;
+};
+export type TailSource = {
+    readonly reader: TailReader;
+    readonly locate: (input: MetadataSession) => TailLocation | null;
+    readonly located: 'launch' | 'reported';
+};
+export type Fields = Readonly<Record<string, unknown>>;
+export declare const fieldsOf: (value: unknown) => Fields | null;
+export declare const textOf: (value: unknown) => string | null;
+export declare const blocksOf: (content: unknown) => readonly Fields[];
+export declare const textBlocks: (content: unknown) => string;
+export declare const answered: (text: string) => TailEnd;
+export declare const isoStamp: (value: unknown) => number | null;
+export type ArtifactFold = {
+    readonly fold: (rootKey: string) => MetadataFold<{
+        readonly bound: boolean;
+    }>;
+    readonly scan: 'one-record' | 'whole-file';
+};
+export type MetadataReader = {
+    readonly sources: (input: MetadataSession) => readonly MetadataLocation[];
+    readonly provenance: {
+        readonly [K in MetadataField]: MetadataFieldSource;
+    };
+    readonly words?: {
+        readonly sources: (input: MetadataSession) => readonly WordsSource[];
+        readonly usage: boolean;
+    };
+    readonly ends?: TailSource;
+    readonly artifact?: ArtifactFold;
+};
+export {};

package/adapter/metadata.js

@@ -0,0 +1,4 @@
+// @bun
+import{Data as S,Schema as p}from"effect";import{isAbsolute as H,join as k}from"path";import{Schema as o}from"effect";var y=200,f=160,A=o.String.check(o.isPattern(/^[a-z][a-z0-9-]*$/u),o.isMaxLength(64)),C=["tagma","lode"],R="tagma",x=o.Literals(["configured","serving","last-recorded"]),T=o.Literals(["hook","vendor-record","transcript","session-store","terminal","protocol"]),P=o.Union([o.Struct({read:o.Literal("value"),value:o.String.check(o.isMaxLength(y)),claim:x}),o.Struct({read:o.Literal("absent")}),o.Struct({read:o.Literal("unsupported")}),o.Struct({read:o.Literal("unreadable"),reason:o.String.check(o.isMaxLength(f))})]),E=o.Struct({value:o.String,label:o.String,description:o.optional(o.String)}),_=o.Literals(["choice"]),O=o.Struct({id:o.NullOr(o.String.check(o.isMinLength(1))),tool:o.String.check(o.isMinLength(1)),subject:o.String.check(o.isMinLength(1))}),F=["catalog","proxy"],h=1e4,N={chars:h,basis:"unmeasured"},g="tagma";function K(e){let r=e[g];if(r===null)throw Error(`The harness cannot express permission stance ${g}.`);return r}function L(e,r){if(r===void 0)return[];let n=r.rung===null?r.model:`${r.model} at ${r.rung}`;if(e===null)throw Error(`The harness declares no model surface and cannot launch on ${n}.`);return e.argv(r)}var W={_tag:"char",char:"\x03"},j=()=>null,I=()=>null,q=(e)=>(r,n)=>n.length===1?e(r,n[0]):null,V=(e,r)=>{if(e.selected===null)return null;let n=e.options.findIndex((a)=>a.value===e.selected),t=e.options.findIndex((a)=>a.value===r);if(n<0||t<0)return null;let s=t>n?"down":"up";return[...Array.from({length:Math.abs(t-n)}).fill(s),"enter"]},D=(e,r)=>e.options.some((n)=>n.value===r)?[...r].map((n)=>({_tag:"char",char:n})):null,Q=(e,r,n=e.findLastIndex((t)=>r(t)!==null))=>{if(n<0)return null;let t=[],s=[],a=n;for(;a>=0;a-=1){let l=r(e[a]);if(l===null)break;if(t.push({value:l.value,label:l.label}),l.selected)s.push(l.value)}return t.reverse(),{options:t,selected:s.length===1?s[0]:null,marked:s.length,above:a}},i={asksFrom:"never"},d={asksFrom:"review",timeout:"none"},U={names:"kind",byName:{bash:{kind:"execute",approval:d},read:{kind:"read",approval:i},ls:{kind:"read",approval:i},glob:{kind:"read",approval:i},grep:{kind:"read",approval:i},write:{kind:"write",approval:d},edit:{kind:"write",approval:d},delete:{kind:"write",approval:d},rename:{kind:"write",approval:d},webfetch:{kind:"network",approval:d},websearch:{kind:"network",approval:d}}};class u extends S.TaggedError("MetadataInvalid"){}var Y=()=>({model:null,effort:null,title:null}),B=p.String.check(p.isMaxLength(y)),Z=(e,r=null)=>e===void 0||e===null||e.trim()===""?null:{value:e,claim:"last-recorded",turnId:r},ee=(e)=>{try{return JSON.parse(e)}catch{throw new u({reason:"malformed"})}},re=(e)=>{let r=p.decodeUnknownResult(e);return(n)=>{let t=r(n);if(t._tag==="Failure")throw new u({reason:"malformed"});return t.success}},ne=(e,r,n)=>{let t=new Map(e.storage.entries.map((c)=>[c.name,c.value])),s=t.get(r),a=t.get("HOME"),l=s??(a===void 0?void 0:k(a,n));return l!==void 0&&H(l)?l:null};function oe(e,r,n,t,s="transcript",a=!1){if(e===null||r===void 0)return{kind:"unreadable",reason:"source-location-unavailable",source:s,fields:t};return a?{kind:"file",root:e,path:r,fold:n,computed:a,source:s,fields:t}:{kind:"file",root:e,path:r,fold:n,source:s,fields:t}}var te=()=>({said:[],requests:new Map,compacted:null}),m=(e)=>{let r=e===void 0?Number.NaN:Date.parse(e);return Number.isNaN(r)?null:r};function M(e){if(typeof e==="string")return[e];if(!Array.isArray(e))return[];return e.flatMap((r)=>{if(typeof r!=="object"||r===null)return[];let n=r;return(n.type==="text"||n.type==="input_text")&&typeof n.text==="string"?[n.text]:[]})}function ae(e,r){let n=M(e);if(n.join(`
+`).trim()==="")return null;let t=n.filter((s)=>{let a=s.trim();return a!==""&&!a.startsWith("<")&&!a.startsWith("# AGENTS.md")});return{texts:n,typed:t,at:m(r)}}var v=(e)=>typeof e==="object"&&e!==null&&!Array.isArray(e)?e:null,se=(e)=>typeof e==="string"?e:null,b=(e)=>Array.isArray(e)?e.flatMap((r)=>{let n=v(r);return n===null?[]:[n]}):[],le=(e)=>typeof e==="string"?e:b(e).flatMap((r)=>r.type==="text"&&typeof r.text==="string"?[r.text]:[]).join(`
+`),de=(e)=>({_tag:"Completed",message:e.trim()===""?null:e}),ie=(e)=>typeof e==="string"?m(e):null;export{u as MetadataInvalid,de as answered,b as blocksOf,Y as emptyValues,v as fieldsOf,oe as fileSource,ie as isoStamp,ee as jsonValue,re as metadataDecode,B as metadataText,Z as recordedValue,m as stampMillis,ne as storageHome,le as textBlocks,se as textOf,ae as transcriptSaid,te as unsaid,M as userTexts};

package/adapter/payload.d.ts

@@ -0,0 +1,19 @@
+/// <reference path="../types/node/index.d.ts" />
+/// <reference path="../host.d.ts" />
+import type { FileEffect, HarnessCall, HarnessModelReport } from "@runlith/tagma/adapter/harness";
+export declare const tail: (prompt: string | undefined) => string[];
+export declare function field(event: Record<string, unknown>, name: string): string | null;
+export declare function nested(event: Record<string, unknown>, name: string): Record<string, unknown>;
+export declare const sessionIdOf: (event: Record<string, unknown>) => string | null;
+export declare const unasked: () => null;
+export declare const unturned: () => null;
+export declare const unreported: () => null;
+export declare const answerField: (said: Record<string, unknown>, key: string | null) => string | null;
+export declare const unfiled: () => readonly FileEffect[];
+export declare const unprinted: () => null;
+export declare function patchFiles(patch: string): readonly FileEffect[];
+export declare const questionTool: (tool?: string) => boolean;
+export declare const rootOfArgv: (resumeWord: string, assigns?: boolean) => (argv: readonly string[]) => string | null;
+export declare const modelField: (event: Record<string, unknown>, defaults?: readonly string[]) => HarnessModelReport | null;
+export declare const namedCall: (event: Record<string, unknown>) => HarnessCall | null;
+export declare const toolCall: (event: Record<string, unknown>, tools: Record<string, string>) => HarnessCall | null;

package/adapter/payload.js

@@ -0,0 +1,3 @@
+// @bun
+var a=(n)=>n===void 0?[]:[n];function o(n,e){let t=n[e];return typeof t==="string"&&t.trim().length>0?t.trim():null}function c(n,e){let t=n[e];return t!==null&&typeof t==="object"&&!Array.isArray(t)?t:{}}var f=(n)=>o(n,"session_id")??o(n,"sessionId"),p=()=>null,g=()=>null,m=()=>null,h=(n,e)=>e===null?null:o(n,e),_=()=>[],w=()=>null,d=[{mark:"*** Add File:",effect:"write"},{mark:"*** Update File:",effect:"write"},{mark:"*** Delete File:",effect:"delete"}],u="*** Move to:";function k(n){let e=[];for(let t of n.split(`
+`)){let r=d.find((i)=>t.startsWith(i.mark));if(r!==void 0){let i=t.slice(r.mark.length).trim();if(i.length>0)e.push({effect:r.effect,path:i});continue}if(!t.startsWith(u))continue;let l=t.slice(u.length).trim(),s=e[e.length-1];if(l.length===0)continue;if(s?.effect==="write")e[e.length-1]={effect:"move",path:l,from:s.path};else e.push({effect:"write",path:l})}return e}var x=(n)=>["askuserquestion","ask_user_question","request_user_input"].includes(n?.toLowerCase()??""),R=(n,e=!1)=>(t)=>{let r=e?[n,"--session-id"]:[n];for(let l=1;l<t.length;l+=1){let s=t[l];if(s!==void 0&&r.includes(s))return t[l+1]??null}return null},y=(n,e=[])=>{if(!("model"in n))return null;let t=o(n,"model");if(t===null)return{read:"absent"};return{read:"value",value:t,claim:e.includes(t)?"configured":"serving"}},F=(n)=>{let e=o(n,"tool_name")??o(n,"toolName");if(e===null)return null;let t=c(n,"tool_input"),r=o(t,"command")??o(t,"cmd")??o(t,"file_path")??o(t,"notebook_path")??o(t,"path")??o(t,"url")??o(t,"query")??o(t,"pattern")??o(n,"tool_input")??JSON.stringify(n.tool_input??{});return{id:o(n,"tool_use_id")??o(n,"toolUseId"),tool:e,subject:r}},E=(n,e)=>{let t=e[(o(n,"tool_name")??o(n,"toolName")??"").toLowerCase()];if(t===void 0)return null;let r=c(n,"tool_input"),l=t==="bash"?o(r,"command"):o(r,"file_path");return l===null?null:{id:o(n,"tool_use_id")??o(n,"toolUseId"),tool:t,subject:l}};export{h as answerField,o as field,y as modelField,F as namedCall,c as nested,k as patchFiles,x as questionTool,R as rootOfArgv,f as sessionIdOf,a as tail,E as toolCall,p as unasked,_ as unfiled,w as unprinted,m as unreported,g as unturned};

package/adapter/provider.d.ts

@@ -0,0 +1,209 @@
+/// <reference path="../types/node/index.d.ts" />
+/// <reference path="../host.d.ts" />
+import type { Effect } from "effect";
+import type { HttpClient } from "effect/http";
+import type { SettingField } from "@runlith/tagma/adapter/settings";
+import type { ProviderDescription } from "@runlith/llm/models/description";
+import type { StoredCredential } from "@runlith/tagma/internal/packages/llm/src/oauth/credential";
+import type { SubscriptionAccounts } from "@runlith/llm/oauth/vendor";
+import type { ModelCredentials, ProductIdentity, ProviderQuota, ProviderRegistration } from "@runlith/llm/profiles/contract";
+import type { ModelSpecs } from "@runlith/llm/models/description";
+import type { Usage } from "@runlith/llm/schema/events";
+import type { JsonSchema } from "@runlith/llm/schema/ids";
+import type { HarnessSurfaces } from "@runlith/tagma/adapter/harness";
+export declare const PROGRAM_REFUSALS: readonly [
+    "ask-not-connected",
+    "ask-quota",
+    "ask-input-too-large",
+    "ask-unreadable-answer",
+    "ask-provider-failed"
+];
+export type ProgramRefusal = (typeof PROGRAM_REFUSALS)[number];
+export type ProgramAsk = {
+    readonly model: string;
+    readonly rung: string | null;
+    readonly system: string;
+    readonly schema?: JsonSchema;
+};
+export type ProgramOutput = {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exit: number | null;
+};
+export type ProgramAnswer = ({
+    readonly _tag: 'Text';
+    readonly text: string;
+} | {
+    readonly _tag: 'Object';
+    readonly object: unknown;
+} | {
+    readonly _tag: 'Refused';
+    readonly refusal: ProgramRefusal;
+    readonly message: string;
+}) & {
+    readonly usage?: Usage;
+};
+export type CommandProgram = {
+    readonly command: string;
+    readonly schemas: boolean;
+    readonly progress?: boolean;
+    argv(ask: ProgramAsk): readonly string[];
+    answer(output: ProgramOutput): ProgramAnswer;
+};
+export type RunnerProgram = {
+    readonly runner: string;
+    answer(output: ProgramOutput): ProgramAnswer;
+};
+export type AskProgram = CommandProgram | RunnerProgram;
+export type ProviderAsks = {
+    readonly program?: AskProgram;
+};
+export type CatalogModels = {
+    readonly models: ModelSpecs;
+    readonly defaultTextModel: string;
+    readonly warnings?: readonly string[];
+};
+export type ProviderCatalogReader = {
+    read(credentials: ModelCredentials, ownerId: string, account?: string): Effect.Effect<CatalogModels, {
+        readonly message: string;
+    }, HttpClient.HttpClient>;
+};
+export type AccountEnvironment = {
+    readonly _tag: 'Set';
+    readonly name: string;
+    readonly value: string;
+} | {
+    readonly _tag: 'Unset';
+    readonly name: string;
+};
+export type HarnessAccountAddress = {
+    readonly directory: string | null;
+    readonly entries: readonly AccountEnvironment[];
+};
+export type CliHarnessCatalogReader = {
+    read(address: HarnessAccountAddress): Effect.Effect<CatalogModels, {
+        readonly message: string;
+    }, HttpClient.HttpClient>;
+};
+export type CommandExchange = {
+    readonly input: string;
+    readonly complete: (line: string) => boolean;
+};
+export type HarnessCommand = {
+    readonly program: string;
+    readonly args: readonly string[];
+    readonly exchange?: CommandExchange;
+};
+export type HarnessOutput = {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+};
+export type HarnessLoginStatus = {
+    readonly kind: 'signed-in';
+    readonly label: string;
+} | {
+    readonly kind: 'signed-out';
+} | {
+    readonly kind: 'unsupported-method';
+    readonly method: string;
+} | {
+    readonly kind: 'unreadable';
+    readonly reason: string;
+};
+export type HarnessAccountAuth = {
+    readonly directory: string;
+    readonly login: HarnessCommand;
+    readonly status: HarnessCommand;
+    readonly loggedIn: (output: HarnessOutput) => Effect.Effect<HarnessLoginStatus>;
+    readonly discovery?: {
+        readonly variable: string;
+        readonly directory: string;
+        readonly files: readonly string[];
+    };
+    readonly renew?: HarnessCommand;
+};
+export type BorrowedAccounts = {
+    readonly provider: string;
+    readonly renewOnReject?: true;
+    readonly missing?: string;
+    read(directory: string | null): Effect.Effect<StoredCredential | null, {
+        readonly message: string;
+    }>;
+};
+export type AccountMode = {
+    readonly section: string;
+    readonly title: string;
+    readonly default: string;
+    readonly id: string;
+    readonly label: string;
+    readonly hint: string;
+    readonly signInLabel?: string;
+    readonly missing?: string;
+    readonly defaultPlace?: string;
+};
+export type WireProvider = ProviderRegistration & {
+    readonly accountMode?: AccountMode;
+    readonly kind: 'wire';
+    readonly accounts?: SubscriptionAccounts;
+    readonly borrows?: BorrowedAccounts;
+    readonly icon?: string;
+    readonly accountsLabel?: string;
+    readonly keyHint?: string;
+    readonly quotaFromReplies?: true;
+    readonly catalog?: ProviderCatalogReader;
+};
+type HarnessDescription = ProviderDescription & HarnessSurfaces & {
+    readonly kind: 'harness';
+    readonly accountMode?: AccountMode;
+    readonly icon?: string;
+    readonly quota?: ProviderQuota;
+    readonly keyHint?: string;
+    readonly asks?: ProviderAsks;
+};
+export type CliHarnessProvider = HarnessDescription & {
+    readonly auth: 'cli';
+    readonly catalog?: CliHarnessCatalogReader;
+    readonly accounts?: HarnessAccountAuth;
+    environment(directory: string | null): readonly AccountEnvironment[];
+};
+export type KeyHarnessProvider = HarnessDescription & {
+    readonly auth: 'api-key';
+    readonly catalog?: ProviderCatalogReader;
+    readonly accounts: SubscriptionAccounts;
+    environment(credential: StoredCredential): readonly AccountEnvironment[];
+};
+export type HarnessProvider = CliHarnessProvider | KeyHarnessProvider;
+export type Provider = WireProvider | HarnessProvider;
+export type SettingValue = string | number | boolean | readonly string[] | readonly SettingRow[];
+export type SettingRow = {
+    readonly [field: string]: SettingValue | undefined;
+};
+export type SettingInstance = {
+    readonly id: string;
+    readonly values: SettingRow;
+    readonly revision?: string;
+};
+export type DiscoveryFailure = {
+    readonly message: string;
+};
+export type AdapterSettings = {
+    readonly title: string;
+    readonly instance: string;
+    readonly name: string;
+    readonly fields: readonly SettingField[];
+    validate?(values: SettingRow): string | null;
+    discover?(values: SettingRow, secrets: SettingRow): Effect.Effect<readonly SettingRow[], DiscoveryFailure>;
+};
+export type HostInstance = SettingInstance & {
+    readonly secrets: SettingRow;
+};
+export type AdapterHost = {
+    readonly product: ProductIdentity;
+    readonly instances: readonly HostInstance[];
+};
+export type Adapter = ((host: AdapterHost) => readonly Provider[]) & {
+    readonly settings?: AdapterSettings;
+};
+export declare const defineAdapter: (provide: (host: AdapterHost) => readonly Provider[], settings?: AdapterSettings) => Adapter;
+export {};

package/adapter/provider.js

@@ -0,0 +1,2 @@
+// @bun
+var n=["ask-not-connected","ask-quota","ask-input-too-large","ask-unreadable-answer","ask-provider-failed"],o=(e,r)=>r===void 0?e:Object.assign((t)=>e(t),{settings:r});export{n as PROGRAM_REFUSALS,o as defineAdapter};

package/adapter/settings.d.ts

@@ -0,0 +1,182 @@
+/// <reference path="../types/node/index.d.ts" />
+/// <reference path="../host.d.ts" />
+import { Schema } from "effect";
+export declare const settingLeafSchema: Schema.Union<readonly [
+    Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly placeholder: Schema.optional<Schema.String>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly hint: Schema.optional<Schema.String>;
+        readonly required: Schema.optional<Schema.Literal<true>>;
+        readonly secret: Schema.optional<Schema.Literal<true>>;
+    }>,
+    Schema.Struct<{
+        readonly type: Schema.Literal<"number">;
+        readonly min: Schema.optional<Schema.Number>;
+        readonly unit: Schema.optional<Schema.String>;
+        readonly placeholder: Schema.optional<Schema.String>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly hint: Schema.optional<Schema.String>;
+        readonly required: Schema.optional<Schema.Literal<true>>;
+        readonly secret: Schema.optional<Schema.Literal<true>>;
+    }>,
+    Schema.Struct<{
+        readonly type: Schema.Literal<"flag">;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly hint: Schema.optional<Schema.String>;
+        readonly required: Schema.optional<Schema.Literal<true>>;
+        readonly secret: Schema.optional<Schema.Literal<true>>;
+    }>,
+    Schema.Struct<{
+        readonly type: Schema.Literal<"choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+        }>>;
+        readonly default: Schema.optional<Schema.String>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly hint: Schema.optional<Schema.String>;
+        readonly required: Schema.optional<Schema.Literal<true>>;
+        readonly secret: Schema.optional<Schema.Literal<true>>;
+    }>,
+    Schema.Struct<{
+        readonly type: Schema.Literal<"set">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+        }>>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly hint: Schema.optional<Schema.String>;
+        readonly required: Schema.optional<Schema.Literal<true>>;
+        readonly secret: Schema.optional<Schema.Literal<true>>;
+    }>
+]>;
+export type SettingLeaf = typeof settingLeafSchema.Type;
+export declare const settingFieldSchema: Schema.Union<readonly [
+    Schema.Union<readonly [
+        Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly placeholder: Schema.optional<Schema.String>;
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly hint: Schema.optional<Schema.String>;
+            readonly required: Schema.optional<Schema.Literal<true>>;
+            readonly secret: Schema.optional<Schema.Literal<true>>;
+        }>,
+        Schema.Struct<{
+            readonly type: Schema.Literal<"number">;
+            readonly min: Schema.optional<Schema.Number>;
+            readonly unit: Schema.optional<Schema.String>;
+            readonly placeholder: Schema.optional<Schema.String>;
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly hint: Schema.optional<Schema.String>;
+            readonly required: Schema.optional<Schema.Literal<true>>;
+            readonly secret: Schema.optional<Schema.Literal<true>>;
+        }>,
+        Schema.Struct<{
+            readonly type: Schema.Literal<"flag">;
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly hint: Schema.optional<Schema.String>;
+            readonly required: Schema.optional<Schema.Literal<true>>;
+            readonly secret: Schema.optional<Schema.Literal<true>>;
+        }>,
+        Schema.Struct<{
+            readonly type: Schema.Literal<"choice">;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+            }>>;
+            readonly default: Schema.optional<Schema.String>;
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly hint: Schema.optional<Schema.String>;
+            readonly required: Schema.optional<Schema.Literal<true>>;
+            readonly secret: Schema.optional<Schema.Literal<true>>;
+        }>,
+        Schema.Struct<{
+            readonly type: Schema.Literal<"set">;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+            }>>;
+            readonly id: Schema.String;
+            readonly label: Schema.String;
+            readonly hint: Schema.optional<Schema.String>;
+            readonly required: Schema.optional<Schema.Literal<true>>;
+            readonly secret: Schema.optional<Schema.Literal<true>>;
+        }>
+    ]>,
+    Schema.Struct<{
+        readonly type: Schema.Literal<"rows">;
+        readonly noun: Schema.String;
+        readonly fields: Schema.$Array<Schema.Union<readonly [
+            Schema.Struct<{
+                readonly type: Schema.Literal<"text">;
+                readonly placeholder: Schema.optional<Schema.String>;
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+                readonly hint: Schema.optional<Schema.String>;
+                readonly required: Schema.optional<Schema.Literal<true>>;
+                readonly secret: Schema.optional<Schema.Literal<true>>;
+            }>,
+            Schema.Struct<{
+                readonly type: Schema.Literal<"number">;
+                readonly min: Schema.optional<Schema.Number>;
+                readonly unit: Schema.optional<Schema.String>;
+                readonly placeholder: Schema.optional<Schema.String>;
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+                readonly hint: Schema.optional<Schema.String>;
+                readonly required: Schema.optional<Schema.Literal<true>>;
+                readonly secret: Schema.optional<Schema.Literal<true>>;
+            }>,
+            Schema.Struct<{
+                readonly type: Schema.Literal<"flag">;
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+                readonly hint: Schema.optional<Schema.String>;
+                readonly required: Schema.optional<Schema.Literal<true>>;
+                readonly secret: Schema.optional<Schema.Literal<true>>;
+            }>,
+            Schema.Struct<{
+                readonly type: Schema.Literal<"choice">;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly label: Schema.String;
+                }>>;
+                readonly default: Schema.optional<Schema.String>;
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+                readonly hint: Schema.optional<Schema.String>;
+                readonly required: Schema.optional<Schema.Literal<true>>;
+                readonly secret: Schema.optional<Schema.Literal<true>>;
+            }>,
+            Schema.Struct<{
+                readonly type: Schema.Literal<"set">;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly label: Schema.String;
+                }>>;
+                readonly id: Schema.String;
+                readonly label: Schema.String;
+                readonly hint: Schema.optional<Schema.String>;
+                readonly required: Schema.optional<Schema.Literal<true>>;
+                readonly secret: Schema.optional<Schema.Literal<true>>;
+            }>
+        ]>>;
+        readonly discoverable: Schema.optional<Schema.Literal<true>>;
+        readonly id: Schema.String;
+        readonly label: Schema.String;
+        readonly hint: Schema.optional<Schema.String>;
+        readonly required: Schema.optional<Schema.Literal<true>>;
+        readonly secret: Schema.optional<Schema.Literal<true>>;
+    }>
+]>;
+export type SettingField = typeof settingFieldSchema.Type;

package/adapter/settings.js

@@ -0,0 +1,2 @@
+// @bun
+import{Schema as t}from"effect";var i=t.Struct({id:t.String,label:t.String}),e={id:t.String,label:t.String,hint:t.optional(t.String),required:t.optional(t.Literal(!0)),secret:t.optional(t.Literal(!0))},r=t.Union([t.Struct({...e,type:t.Literal("text"),placeholder:t.optional(t.String)}),t.Struct({...e,type:t.Literal("number"),min:t.optional(t.Number),unit:t.optional(t.String),placeholder:t.optional(t.String)}),t.Struct({...e,type:t.Literal("flag")}),t.Struct({...e,type:t.Literal("choice"),options:t.Array(i),default:t.optional(t.String)}),t.Struct({...e,type:t.Literal("set"),options:t.Array(i)})]),n=t.Union([r,t.Struct({...e,type:t.Literal("rows"),noun:t.String,fields:t.Array(r),discoverable:t.optional(t.Literal(!0))})]);export{n as settingFieldSchema,r as settingLeafSchema};

package/adapter/speech.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../types/node/index.d.ts" />
+/// <reference path="../host.d.ts" />
+import type { AnyProvider, SpeechHost, SpeechProvider } from "@runlith/speech/protocol/adapter";
+export declare const defineSpeech: <Credential>(provider: SpeechProvider<Credential, SpeechHost>) => AnyProvider<SpeechHost>;

package/adapter/speech.js

@@ -0,0 +1,2 @@
+// @bun
+var r=(e)=>e;export{r as defineSpeech};