@jdsl/router 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# @jdsl/router
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run ./src/index.ts
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@jdsl/router",
+  "version": "0.1.0",
+  "type": "module",
+  "author": "Machar Kook",
+  "license": "Apache-2.0",
+  "module": "./src/index.ts",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@effect/cli": "^0.75.2",
+    "@effect/platform": "^0.96.2",
+    "@effect/platform-bun": "^0.90.0",
+    "@effect/platform-node": "^0.107.0",
+    "effect": "3.21.0"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./config": "./src/config.ts",
+    "./error": "./src/types",
+    "./models-dev": "./src/models/models-dev.ts"
+  }
+}

package/src/config.ts

@@ -0,0 +1,96 @@
+import { homedir } from "os";
+import { dirname } from "path";
+
+import { Either, Effect, Schema } from "effect";
+import { FileSystem, Path } from "@effect/platform";
+import { AiProvider } from "../../provider/src/providers.ts";
+import { LoadAPIKeyError } from "./types.ts";
+
+export const ProvidersList = Schema.Literal("anthropic", "deepseek", "google", "nvidia", "openai", "recon", "zhipuai", "zai", "zai-coding-plan", "zhipuai-coding-plan");
+export type Providers = typeof ProvidersList.Type;
+
+const ProviderConfig = Schema.Struct({
+    apiKey: Schema.Array(Schema.String),
+});
+
+const ConfigSchema = Schema.Struct({
+    "anthropic": Schema.optional(ProviderConfig),
+    "deepseek": Schema.optional(ProviderConfig),
+    "google": Schema.optional(ProviderConfig),
+    "nvidia": Schema.optional(ProviderConfig),
+    "openai": Schema.optional(ProviderConfig),
+    "recon": Schema.optional(ProviderConfig),
+    "zhipuai": Schema.optional(ProviderConfig),
+    "zai": Schema.optional(ProviderConfig),
+    "zai-coding-plan": Schema.optional(ProviderConfig),
+    "zhipuai-coding-plan": Schema.optional(ProviderConfig),
+})
+
+interface Config extends Schema.Schema.Type<typeof ConfigSchema> { }
+
+export class AiModelConfig extends Effect.Service<AiModelConfig>()(
+    "AiModelConfig",
+    {
+        effect: Effect.gen(function* () {
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+            const provider = yield* AiProvider;
+
+            let config: Config;
+
+            const home = homedir();
+            const configFilename = "auth.json";
+            const configDir = ".local/share/recon";
+            const configPath = path.join(home, configDir, configFilename);
+
+            const openConfig = (filePath: string) => Effect.gen(function* () {
+                const configResult = yield* fs.readFileString(filePath);
+                const parsedJsonObj = JSON.parse(configResult);
+                const config = yield* Schema.decode(ConfigSchema)(parsedJsonObj);
+                return config as Config;
+            })
+
+            const saveConfig = (cfg: Config) => Effect.gen(function* () {
+                const oldConfig = yield* Effect.either(openConfig(configPath));
+                let newConfig: Config;
+
+                if (Either.isLeft(oldConfig)) {
+                    newConfig = {};
+                } else {
+                    const encodedConfig = yield* Schema.encode(ConfigSchema)(cfg);
+                    newConfig = { ...oldConfig.right, ...encodedConfig };
+                }
+                config = newConfig;
+                const jsonString = JSON.stringify(newConfig, null, 2);
+
+                const dirPath = dirname(configPath);
+                const dirExists = yield* fs.exists(dirPath);
+                if (!dirExists) {
+                    yield* fs.makeDirectory(dirPath, { recursive: true });
+                }
+
+                yield* fs.writeFileString(configPath, jsonString,);
+            })
+
+            const getConfig = () => Effect.gen(function* () {
+                const currentProvider = yield* provider.getProvider();
+                const cfg = config[currentProvider];
+                return cfg ? cfg : yield* new LoadAPIKeyError({name: "config", msg: `${currentProvider} apiKey/auth is missing`, isRetryable: false})
+            })
+
+            const listConfig = () => Effect.gen(function* () {
+                return config;
+            })
+
+            const configResult = yield* Effect.either(openConfig(configPath));
+            if (Either.isLeft(configResult)) {
+                yield* saveConfig({});
+                config = {};
+            } else {
+                config = configResult.right;
+            }
+
+            return { getConfig, listConfig, saveConfig } as const;
+        })
+    }
+) { }

package/src/index.ts

@@ -0,0 +1,19 @@
+import { Effect, Layer } from "effect";
+
+export class Router extends Effect.Service<Router>()(
+    "Router",
+    {
+        effect: Effect.gen(function* () {
+            const getConfig = () => "Router";
+
+            return { getConfig } as const;
+        })
+    }
+){}
+
+export const RoundRobinRouter = Layer.effect(Router, Effect.gen(function* () {
+    return Router.make({
+    getConfig: () => "Round Robin Router"
+})
+}))
+

package/src/models/modelSchema.ts

@@ -0,0 +1,81 @@
+import { Schema } from "effect"
+
+const DateString = Schema.String.pipe(
+    Schema.pattern(/^\d{4}-\d{2}(-\d{2})?$/)
+);
+
+const InterleavedObject = Schema.Struct({
+    field: Schema.Literal("reasoning_content", "reasoning_details")
+});
+
+const InterleavedSchema = Schema.Union(
+    Schema.Boolean,
+    InterleavedObject
+);
+
+const CostSchema = Schema.Struct({
+    input: Schema.Number,
+    output: Schema.Number,
+
+    reasoning: Schema.optional(Schema.Number),
+    cache_read: Schema.optional(Schema.Number),
+    cache_write: Schema.optional(Schema.Number),
+    input_audio: Schema.optional(Schema.Number),
+    output_audio: Schema.optional(Schema.Number)
+});
+
+const LimitSchema = Schema.Struct({
+    context: Schema.Number,
+    input: Schema.optional(Schema.Number),
+    output: Schema.Number
+});
+
+const ModalitiesSchema = Schema.Struct({
+    input: Schema.Array(Schema.String),
+    output: Schema.Array(Schema.String)
+});
+
+const StatusSchema = Schema.Literal(
+    "alpha",
+    "beta",
+    "deprecated"
+);
+
+const ModelSchema = Schema.Struct({
+    name: Schema.String,
+    id: Schema.String,
+    family: Schema.optional(Schema.String),
+
+    attachment: Schema.Boolean,
+    reasoning: Schema.Boolean,
+    tool_call: Schema.Boolean,
+    structured_output: Schema.optional(Schema.Boolean),
+    temperature: Schema.optional(Schema.Boolean),
+
+    knowledge: Schema.optional(DateString),
+    release_date: DateString,
+    last_updated: DateString,
+    open_weights: Schema.Boolean,
+
+    interleaved: Schema.optional(InterleavedSchema),
+
+    cost: Schema.optional(CostSchema),
+    limit: LimitSchema,
+    modalities: ModalitiesSchema,
+    status: Schema.optional(StatusSchema)
+});
+export interface Model extends Schema.Schema.Type<typeof ModelSchema> { };
+
+const ProviderSchema = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    npm: Schema.String,
+    env: Schema.Array(Schema.String),
+    doc: Schema.String,
+    api: Schema.optional(Schema.String),
+    models: Schema.Record({key: Schema.String, value: ModelSchema})
+});
+export interface Provider extends Schema.Schema.Type<typeof ProviderSchema> { };
+
+export const ModelsDevSchema = Schema.Record({key: Schema.String, value: ProviderSchema});
+export interface ModelProviders extends Schema.Schema.Type<typeof ModelsDevSchema> { };

package/src/models/models-dev.ts

@@ -0,0 +1,91 @@
+import { homedir } from "os";
+
+import { Data, Effect, Option, Schema } from "effect";
+import { FileSystem, Path } from "@effect/platform";
+
+import { type ModelProviders, type Provider, ModelsDevSchema } from "./modelSchema.ts";
+import type { Providers } from "../config.ts";
+import { NoSuchModelError } from "../types.ts";
+
+export class FetchError extends Data.TaggedError("FetchError")<{ name: string, msg: string, isRetryable: boolean }> { }
+export class CacheError extends Data.TaggedError("CacheError")<{ msg: string }> { }
+
+export class ModelsDev extends Effect.Service<ModelsDev>()(
+    "ModelsDev",
+    {
+        effect: Effect.gen(function* () {
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+
+            let models: ModelProviders;
+
+            const home = homedir();
+            const modelCacheFilename = "models-dev.json";
+            const modelCacheDir = ".local/share/recon"
+            const modelCachePath = path.join(home, modelCacheDir, modelCacheFilename);
+
+            const fetchModels = Effect.gen(function* () {
+                const getModels = Effect.tryPromise(async () => {
+                    const url = "https://models.dev/api.json";
+                    const response = await fetch(url);
+                    const jsonResponse = await response.json() as any;
+                    return jsonResponse;
+                }).pipe(
+                    Effect.mapError(e => {
+                        new FetchError({name: "FetchError", msg: e.message, isRetryable: true});
+                    })
+                );
+                const models = yield* getModels
+                const result = yield* Schema.decode(ModelsDevSchema)(models);
+                return result as ModelProviders
+            })
+
+            const saveModelCache = (models: ModelProviders) => Effect.gen(function* () {
+                const dirPath = path.dirname(modelCachePath);
+                const dirExists = yield* fs.exists(dirPath);
+                const jsonString = JSON.stringify(models, null, 2);
+                if (!dirExists) {
+                    yield* fs.makeDirectory(dirPath, { recursive: true });
+                }
+                yield* fs.writeFileString(modelCachePath, jsonString);
+            })
+
+            const openModelCache = (filePath: string) => Effect.gen(function* () {
+                const stats = yield* fs.stat(filePath)
+                const now = new Date();
+                const ttlInMillis = 24 * 3600 * 1000;
+                const modifiedTime = Option.getOrThrow(stats.mtime);
+                if ((modifiedTime.getTime() - now.getTime()) > ttlInMillis) {
+                    return yield* new CacheError({ msg: "Saved models cache has expired and should be updated" })
+                }
+
+                const cacheResult = yield* fs.readFileString(filePath);
+                const parsedJsonObj = JSON.parse(cacheResult);
+                const cache = yield* Schema.decode(ModelsDevSchema)(parsedJsonObj);
+                return cache as ModelProviders
+            });
+
+            const getProvider = (provider: Providers) => Effect.gen(function* () {
+                const results = models[provider];
+                if (!results) {
+                    return yield* new NoSuchModelError({ name: "NoSuchModelError", msg: `invalid ${provider}. Could not find ${provider} on models.dev providers`, isRetryable: false })
+                }
+                return results as Provider
+            });
+
+            const listProviders = () => Effect.sync(() => {
+                return Object.keys(models);
+            });
+
+            models = yield* openModelCache(modelCachePath).pipe(
+                Effect.catchAll(() => Effect.gen(function* () {
+                    const modelsCache = yield* fetchModels;
+                    yield* saveModelCache(modelsCache);
+                    return modelsCache;
+                }))
+            )
+
+            return { getProvider, listProviders } as const;
+        })
+    }
+) { }

package/src/types.ts

@@ -0,0 +1,88 @@
+import { Data, Effect } from "effect";
+import type { UnknownException } from "effect/Cause";
+
+import {
+    APICallError as UnknownAPICallError,
+    LoadAPIKeyError as UnknownLoadAPIKeyError,
+    JSONParseError as UnknownJSONParseError,
+    NoSuchModelError as UnknownNoSuchModelError,
+    NoSuchProviderError as UnknownNoSuchProviderError,
+    RetryError as UnknownRetryError,
+    type ContentPart,
+    type FinishReason,
+    type LanguageModelUsage,
+    type ReasoningOutput,
+    type ToolSet
+} from "ai";
+
+export interface GenerateTextResponse {
+    content: ContentPart<ToolSet>[];
+    text: string;
+    reasoning: ReasoningOutput[];
+    reasoningText: string | undefined;
+    finishReason: FinishReason;
+    usage: LanguageModelUsage;
+    totalUsage: LanguageModelUsage;
+}
+
+export interface StreamTextResponse {
+    content: PromiseLike<ContentPart<ToolSet>[]>;
+    text: PromiseLike<string>;
+    textStream: AsyncIterable<string>;
+    reasoning: PromiseLike<ReasoningOutput[]>;
+    reasoningText: PromiseLike<string | undefined>;
+    finishReason: PromiseLike<FinishReason>;
+    usage: PromiseLike<LanguageModelUsage>;
+    totalUsage: PromiseLike<LanguageModelUsage>;
+}
+
+export interface AiError {
+    name: string;
+    msg: string;
+    isRetryable: boolean;
+}
+
+export class APICallError extends Data.TaggedError("ApiCallError")<AiError> { };
+export class LoadAPIKeyError extends Data.TaggedError("LoadAPIKeyError")<AiError> { };
+export class JSONParseError extends Data.TaggedError("JSONParseError")<AiError> { };
+export class NoSuchModelError extends Data.TaggedError("NoSuchModelError")<AiError> { };
+export class NoSuchProviderError extends Data.TaggedError("NoSuchProviderError")<AiError> { };
+export class RetryError extends Data.TaggedError("RetryError")<AiError> { };
+export class InvalidApiKeyError extends Data.TaggedError("InvalidApiKeyError")<AiError> { };
+export class InsufficientBalanceError extends Data.TaggedError("InsufficientBalanceError")<AiError> { };
+export class RateLimitError extends Data.TaggedError("RateLimitError")<AiError> { };
+export class ServerError extends Data.TaggedError("ServerError")<AiError> { };
+
+
+export const mapLanguageModelError = (e: Effect.Effect<GenerateTextResponse | StreamTextResponse, UnknownException, never>) => Effect.mapError(e, (e) => {
+    if (UnknownAPICallError.isInstance(e.cause)) {
+        const cause = e.cause;
+        if (cause.statusCode === 400 || cause.statusCode === 401) {
+            return new InvalidApiKeyError({ name: "InvalidApiKeyError", msg: cause.message, isRetryable: cause.isRetryable });
+        } else if (cause.statusCode === 403) {
+            return new InsufficientBalanceError({ name: "InsufficientBalance", msg: cause.message, isRetryable: cause.isRetryable });
+        } else if (cause.statusCode === 429) {
+            return new RateLimitError({ name: "RateLimitError", msg: cause.message, isRetryable: cause.isRetryable });
+        } else if (cause.statusCode === 500) {
+            return new ServerError({ name: "ServerError", msg: cause.message, isRetryable: cause.isRetryable });
+        }
+        return new APICallError({ name: "APICallError", msg: cause.message, isRetryable: cause.isRetryable });
+    }
+    if (UnknownLoadAPIKeyError.isInstance(e.cause)) {
+        return new LoadAPIKeyError({ name: "LoadAPIKeyError", msg: e.cause.message, isRetryable: false });
+    }
+    if (UnknownJSONParseError.isInstance(e.cause)) {
+        return new JSONParseError({ name: "JSONParseError", msg: e.cause.message, isRetryable: false });
+    }
+    if (UnknownNoSuchModelError.isInstance(e.cause)) {
+        return new NoSuchModelError({ name: "NoSuchModelError", msg: e.cause.message, isRetryable: false });
+    }
+    if (UnknownNoSuchProviderError.isInstance(e.cause)) {
+        return new NoSuchProviderError({ name: "NoSuchProviderError", msg: e.cause.message, isRetryable: false });
+    }
+    if (UnknownRetryError.isInstance(e.cause)) {
+        return new RetryError({ name: "RetryError", msg: e.cause.message, isRetryable: false });
+    }
+
+    return new InvalidApiKeyError({ name: "UnkownCertificateError", msg: "Forbidden Resource, Authorization Failed", isRetryable: false });
+})

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "nodenext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "nodenext",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}