@jdsl/provider 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# providers
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run 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/index.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import { generateText as generateTextAiSdk, streamText as streamTextAiSdk } from "ai";
+
+import { AiModel } from "./src/aiModel.ts";
+
+export class LanguageModel extends Effect.Service<LanguageModel>()(
+    "LanguageModel",
+    {
+        effect: Effect.gen(function* () {
+            const aiModel = yield* AiModel;
+
+            const generateText = (text: string) => Effect.gen(function* () {
+                const model = yield* aiModel.getModel();
+
+                const fromAsync = (prompt: string) => Effect.tryPromise(async () => {
+                    const response = await generateTextAiSdk({
+                        model: model,
+                        prompt: prompt
+                    })
+                    return response
+                })
+                return yield* fromAsync(text)
+            })
+
+            const streamText = (text: string) => Effect.gen(function* () {
+                const model = yield* aiModel.getModel();
+
+                const fromAsync = (prompt: string) => Effect.tryPromise(async () => {
+                    const response = await streamTextAiSdk({
+                        model: model,
+                        prompt: prompt
+                    })
+                    return response
+                })
+                return yield* fromAsync(text)
+            })
+
+            return { generateText, streamText } as const
+        })
+    }
+) { }

package/main.ts

@@ -0,0 +1,18 @@
+import { createProviderRegistry, generateText} from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { google } from '@ai-sdk/google';
+
+google("gemini-2.0-flash");
+export const registry = createProviderRegistry({
+  // register provider with prefix and direct provider import:
+  anthropic,
+  openai,
+});
+
+const { text } = await generateText({
+  model: registry.languageModel('openai:gpt-5.1'), // default separator
+  // or with custom separator:
+  // model: customSeparatorRegistry.languageModel('openai > gpt-5.1'),
+  prompt: 'Invent a new holiday and describe its traditions.',
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@jdsl/provider",
+  "version": "0.1.0",
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.38",
+    "@ai-sdk/google": "^3.0.22",
+    "@ai-sdk/openai": "^3.0.26",
+    "ai": "^6.0.77",
+    "effect": "^3.21.0"
+  },
+  "exports": {
+    ".": "./index.ts",
+    "./aimodel": "./src/aiModel.ts",
+    "./models-dev": "./src/models/models-dev.ts",
+    "./config": "./src/config.ts",
+    "./providers": "./src/providers.ts",
+    "./context": "./src/context/context.ts"
+  }
+}

package/src/aiModel.ts

@@ -0,0 +1,43 @@
+import { Data, Effect } from "effect";
+
+import { createGoogleGenerativeAI, type GoogleGenerativeAIProvider } from "@ai-sdk/google";
+import { createOpenAI, type OpenAIProvider } from "@ai-sdk/openai";
+import { createAnthropic, type AnthropicProvider } from "@ai-sdk/anthropic";
+
+import { AiModelConfig } from "./config.ts";
+import { AiProvider } from "./providers.ts";
+
+export class AiError extends Data.TaggedError("AiError")<{msg: string}>{};
+export type AiModelProvider = AnthropicProvider | GoogleGenerativeAIProvider | OpenAIProvider;
+
+export class AiModel extends Effect.Service<AiModel>()(
+    "AiModel",
+    {
+        effect: Effect.gen(function* () {
+            const modelConfig = yield* AiModelConfig;
+            const modelProvider = yield* AiProvider;
+
+            const getModel = () => Effect.gen(function*() {
+                const config = yield* modelConfig.getConfig();
+                const provider = yield* modelProvider.getProvider();
+
+                switch (provider) {
+                    case "anthropic":
+                        return createAnthropic(config)(yield* modelProvider.getModelName());
+
+                    case "google":
+                        return createGoogleGenerativeAI(config) (yield* modelProvider.getModelName());
+
+                    case "openai":
+                        return createOpenAI(config) (yield* modelProvider.getModelName());
+
+                    default:
+                        return yield* new AiError({msg: `${provider} not supported yet`});
+                }
+            });
+            
+            return {getModel} as const;
+        })
+    }
+){}
+

package/src/config.ts

@@ -0,0 +1,85 @@
+import { homedir } from "os";
+import { dirname } from "path";
+
+import { Either, Effect, Schema } from "effect";
+import { FileSystem, Path } from "@effect/platform";
+import { AiProvider } from "./providers.ts";
+
+export const ProvidersList = Schema.Literal("anthropic", "google", "openai", "recon");
+export type Providers = typeof ProvidersList.Type;
+
+const ProviderConfig = Schema.Struct({
+    apiKey: Schema.optional(Schema.String),
+    authToken: Schema.optional(Schema.String)
+})
+
+const ConfigSchema = Schema.Struct({
+    "anthropic": Schema.optional(ProviderConfig),
+    "google": Schema.optional(ProviderConfig),
+    "openai": Schema.optional(ProviderConfig),
+    "recon": 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()
+                return config[currentProvider] ?? {}
+            })
+
+            const configResult = yield* Effect.either(openConfig(configPath));
+            if (Either.isLeft(configResult)) {
+                yield* saveConfig({});
+                config = {};
+            } else {
+                config = configResult.right;
+            }
+
+            return { getConfig, saveConfig } as const;
+        })
+    }
+) { }

package/src/context/context.ts

@@ -0,0 +1,35 @@
+import { Effect } from "effect";
+
+export interface Content {
+    type: "text" | "image",
+    text: string
+};
+
+export interface Message {
+    role: "user" | "assistant" | "system";
+    content: string | Content[]
+};
+
+export interface Context {
+    system?: string ;
+    message?: string | Message;
+};
+
+export class ContextWindow extends Effect.Service<ContextWindow>()(
+    "ContextWindow",
+    {
+        effect: Effect.gen(function* () {
+            const systemInstructions: string[] = [];
+            const messages: Message[] = []
+
+            const addSystemInstruction = (instruction: string) => Effect.sync(() => systemInstructions.push(instruction));
+            const addMessage = (message: Message) => Effect.sync(() => messages.push(message));
+
+            const join = () => Effect.sync(() => {
+                const system = systemInstructions.join("\n");
+                return {systemInstructions: system, messages: messages};
+            })
+            return { addSystemInstruction, addMessage, join } as const;
+        })
+    }
+) { }

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,136 @@
+import { homedir } from "os";
+import { dirname } from "path";
+import { stat } from "fs";
+import { promisify } from "util";
+
+import { Data, Effect, Either, Schema } from "effect";
+import { FileSystem, Path } from "@effect/platform";
+
+import { type ModelProviders, type Provider, ModelsDevSchema } from "./modelSchema.ts";
+import type { Providers } from "../config.ts";
+
+const CacheMetadataSchema = Schema.Struct({
+    size: Schema.Number,
+    modified: Schema.Date,
+    created: Schema.Date
+})
+interface CacheMetadata extends Schema.Schema.Type<typeof CacheMetadataSchema> { }
+
+export class ModelsDevError extends Data.TaggedError("ModelsDevError")<{ msg: string, error?: unknown }> { }
+export class HttpError extends Data.TaggedError("HttpError")<{ status: number, statusText: string }> { }
+export class JSONParseError extends Data.TaggedError("JSONParseError")<{ error: unknown }> { }
+export class FetchError extends Data.TaggedError("FetchError")<{ error: unknown }> { }
+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({
+                    try: async () => {
+                        const url = "https://models.dev/api.json";
+                        const response = await fetch(url);
+                        if (!response.ok) {
+                            throw new HttpError({ status: response.status, statusText: response.statusText })
+                        }
+                        try {
+                            const jsonResponse = await response.json() as any;
+                            return jsonResponse;
+                        } catch (error) {
+                            throw new JSONParseError({ error })
+                        }
+                    },
+                    catch: (error) => {
+                        if (error instanceof HttpError || error instanceof JSONParseError) {
+                            return error
+                        }
+                        return new FetchError({ error })
+                    }
+                })
+
+                const models = yield* getModels
+                const result = yield* Schema.decode(ModelsDevSchema)(models);
+                return result as ModelProviders
+            })
+
+            const updateModels = Effect.gen(function* () {
+                const cacheStats = yield* Effect.either(getCacheMetadata());
+                const now = new Date();
+                const ttlInMillis = 24 * 3600 * 1000;
+                if (Either.isRight(cacheStats)) {
+                    const stats = cacheStats.right;
+                    const elapsedTime = now.getTime() - Date.parse(stats.modified);
+                    if (elapsedTime > ttlInMillis) {
+                        return true;
+                    }
+                }
+                return false
+            })
+
+            const getCacheMetadata = () => Effect.gen(function* () {
+                const fromAsync = (path: string) => Effect.tryPromise(async () => {
+                    const statPromise = promisify(stat);
+                    return await statPromise(path);
+                })
+                const stats = yield* fromAsync(modelCachePath)
+                return yield* Schema.encode(CacheMetadataSchema)({ size: stats.size, modified: stats.mtime, created: stats.ctime });
+            })
+
+            const getProvider = (provider: Providers) => Effect.gen(function* () {
+                const results = models[provider];
+                if (!results) {
+                    return yield* new ModelsDevError({ msg: `invalid ${provider}. Could not find ${provider} on models.dev providers` })
+                }
+                return results as Provider
+            });
+
+            const listProviders = () => Effect.sync(() => {
+                return Object.keys(models);
+            });
+
+            const openModelCache = (filePath: string) => Effect.gen(function* () {
+                const cacheResult = yield* fs.readFileString(filePath);
+                const parsedJsonObj = JSON.parse(cacheResult);
+                const cache = yield* Schema.decode(ModelsDevSchema)(parsedJsonObj);
+                return cache as ModelProviders
+            })
+
+            const saveModelCache = (models: ModelProviders) => Effect.gen(function* () {
+                const dirPath = 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 modelsCache = yield* Effect.either(openModelCache(modelCachePath))
+            if (Either.isLeft(modelsCache)) {
+                models = yield* fetchModels;
+                yield* saveModelCache(models);
+            }
+            else {
+                const status = yield* updateModels;
+                if (status) {
+                    models = yield* fetchModels;
+                    yield* saveModelCache(models);
+                } else {
+                    models = modelsCache.right
+                }
+            }
+            return { getProvider, listProviders } as const
+        })
+    }
+) { }

package/src/providers.ts

@@ -0,0 +1,59 @@
+import { Data, Effect, Either } from "effect";
+import type { Providers } from "./config.ts";
+import { ModelsDev } from "./models/models-dev.ts";
+import type { Model } from "./models/modelSchema.ts";
+
+export class AiProviderError extends Data.TaggedError("AiProviderError")<{ msg: string}> { }
+export class AiProvider extends Effect.Service<AiProvider>()(
+    "AiProvider",
+    {
+        effect: Effect.gen(function*(){
+            const modelsDev = yield* ModelsDev;
+            let provider: Providers = "recon";
+            let modelName: string = "";
+
+            const chooseProvider = (name: Providers) => Effect.gen(function*() {
+                const providers = yield* modelsDev.listProviders();
+                if (!providers.includes(name)) {
+                    return yield* new AiProviderError({msg: `${name} is not a supported provider`});
+                }
+                provider = name;
+            })
+
+            const chooseModel = (name: string) => Effect.gen(function* () {
+                const modelList = yield* listModels();
+                if (!modelList.includes(name)) {
+                    return yield* new AiProviderError({msg: `${getProvider()} does not have a model ${name}`});
+                }
+                modelName = name
+            })
+
+            const getProvider = () => Effect.succeed(provider);
+
+            const getModelName = () => Effect.gen(function* (){
+                yield* chooseModel(modelName);
+                return modelName
+            })
+
+            const getModelSpecs = () => Effect.gen(function* () {
+                const results = yield* modelsDev.getProvider(provider);
+                const modelSpecs = results.models[modelName];
+
+                if (!modelSpecs) {
+                    return yield* new AiProviderError({msg: `${provider} does not have a model named ${modelName}.`});
+                }
+                return modelSpecs as Model;
+            })
+
+            const listModels = () => Effect.gen(function* () {
+                const models = yield* Effect.either(modelsDev.getProvider(provider));
+                if (Either.isLeft(models)) {
+                    return [] as string[];
+                }
+                return Object.keys(models.right.models);
+            });
+
+            return {chooseModel, chooseProvider, getModelName, getModelSpecs, getProvider, listModels} as const;
+        })
+    }
+){}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "nodenext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "baseUrl": ".",
+
+    // 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
+  }
+}