@em3odme/agentic 0.1.0

package/dist/index.js

@@ -0,0 +1,751 @@
+// src/providers/cloudflare.ts
+var cloudflareAIModel = (model) => ({
+  provider: "cloudflare",
+  model
+});
+
+// src/providers/groq.ts
+var groqAIModel = (model) => ({
+  provider: "groq",
+  model
+});
+
+// src/types.ts
+var ProviderError = class extends Error {
+  constructor(message, provider, statusCode, originalError) {
+    super(message);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.originalError = originalError;
+    this.name = "ProviderError";
+  }
+};
+var ConfigurationError = class extends Error {
+  constructor(message, provider) {
+    super(message);
+    this.provider = provider;
+    this.name = "ConfigurationError";
+  }
+};
+
+// src/providers/BaseModelProvider.ts
+var BaseModelProvider = class {
+  constructor(environment) {
+    this.environment = environment;
+  }
+  validateRequiredKeys(envKeys) {
+    const missing = envKeys.filter((key) => !this.environment[key]);
+    if (missing.length > 0) {
+      throw new ConfigurationError(
+        `Missing required environment variables: ${missing.join(", ")}`,
+        this.providerType
+      );
+    }
+  }
+  createError(message, statusCode, originalError) {
+    return new ProviderError(
+      message,
+      this.providerType,
+      statusCode,
+      originalError
+    );
+  }
+  buildUsageObject(promptTokens, completionTokens, totalTokens) {
+    return {
+      promptTokens,
+      completionTokens,
+      totalTokens
+    };
+  }
+  filterDuplicateToolCalls(toolCalls) {
+    const seen = /* @__PURE__ */ new Set();
+    return toolCalls.filter((toolCall) => {
+      const key = toolCall.function.name;
+      if (seen.has(key)) {
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+  }
+};
+
+// src/providers/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function runWithRetry(fn, maxRetries = 3, delayMs = 1e3, info) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      const isRetryable = error instanceof Error && (error.message?.includes("1031") || error.toString().includes("1031") || error.message?.includes("500"));
+      if (isRetryable && i < maxRetries - 1) {
+        if (info)
+          info(`AI Error (1031/500). Retrying ${i + 1}/${maxRetries}...`);
+        await delay(delayMs * (i + 1));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+// src/providers/CloudflareProvider.ts
+var CloudflareProvider = class extends BaseModelProvider {
+  constructor(environment) {
+    super(environment);
+    this.providerType = "cloudflare";
+    this.validateRequiredKeys(["AI"]);
+  }
+  supportsJsonMode() {
+    return true;
+  }
+  supportsTools() {
+    return true;
+  }
+  async execute(request) {
+    const payload = {
+      messages: request.messages,
+      ...request.options
+    };
+    if (request.jsonMode) {
+      payload.response_format = { type: "json_object" };
+    }
+    try {
+      const response = await runWithRetry(
+        async () => {
+          return this.environment.AI.run(
+            request.model,
+            payload
+          );
+        },
+        3,
+        1e3
+      );
+      return this.parseResponse(response);
+    } catch (error) {
+      throw this.createError(
+        `Cloudflare AI execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        error
+      );
+    }
+  }
+  parseResponse(response) {
+    const content = this.extractContent(response);
+    const toolCalls = this.extractToolCalls(response);
+    const usage = this.buildUsageObject(0, 0, 0);
+    return {
+      content,
+      toolCalls,
+      raw: response,
+      usage
+    };
+  }
+  extractContent(response) {
+    if (typeof response === "string") {
+      return response;
+    }
+    if (response && typeof response === "object") {
+      if ("response" in response) {
+        return String(response.response || "");
+      }
+    }
+    return "";
+  }
+  extractToolCalls(response) {
+    if (!response || typeof response !== "object") {
+      return [];
+    }
+    const toolCalls = response.tool_calls;
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+      return [];
+    }
+    return toolCalls.map((toolCall, index) => {
+      const tc = toolCall;
+      const args = tc.arguments;
+      const argsString = typeof args === "string" ? args : JSON.stringify(args);
+      return {
+        id: `tool-call-${index}`,
+        type: "function",
+        function: {
+          name: String(tc.name || ""),
+          arguments: argsString
+        }
+      };
+    });
+  }
+};
+
+// src/providers/GroqProvider.ts
+var GroqProvider = class extends BaseModelProvider {
+  constructor(environment) {
+    super(environment);
+    this.providerType = "groq";
+    this.apiEndpoint = "https://api.groq.com/openai/v1/chat/completions";
+    this.validateRequiredKeys(["GROQ_API_KEY"]);
+  }
+  supportsJsonMode() {
+    return true;
+  }
+  supportsTools() {
+    return true;
+  }
+  async execute(request) {
+    const payload = this.buildPayload(request);
+    try {
+      const response = await this.makeRequest(payload);
+      return this.parseResponse(response);
+    } catch (error) {
+      if (error instanceof Response) {
+        const errorText = await error.text();
+        throw this.createError(
+          `Groq API Error (${error.status}): ${errorText}. Model: ${request.model}`,
+          error.status,
+          errorText
+        );
+      }
+      throw this.createError(
+        `Groq execution failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        error
+      );
+    }
+  }
+  buildPayload(request) {
+    const payload = {
+      model: request.model,
+      messages: request.messages,
+      ...request.options
+    };
+    if (request.options?.tools) {
+      payload.tool_choice = "auto";
+    }
+    if (request.jsonMode && !request.options?.tools) {
+      payload.response_format = { type: "json_object" };
+    }
+    return payload;
+  }
+  async makeRequest(payload) {
+    const response = await runWithRetry(
+      async () => {
+        return fetch(this.apiEndpoint, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.environment.GROQ_API_KEY}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        });
+      },
+      3,
+      1e3
+    );
+    if (!response) {
+      throw this.createError(
+        `Groq execution failed: No response from Groq API`,
+        void 0,
+        void 0
+      );
+    }
+    return response?.json();
+  }
+  extractContent(data) {
+    return data.choices?.[0]?.message?.content || "";
+  }
+  extractToolCalls(data) {
+    return data.choices?.[0]?.message?.tool_calls || [];
+  }
+  parseResponse(data) {
+    const content = this.extractContent(data);
+    const toolCalls = this.filterDuplicateToolCalls(
+      this.extractToolCalls(data)
+    );
+    const usage = data.usage ? this.buildUsageObject(
+      data.usage.prompt_tokens,
+      data.usage.completion_tokens,
+      data.usage.total_tokens
+    ) : this.buildUsageObject(0, 0, 0);
+    return {
+      content,
+      toolCalls,
+      raw: data,
+      usage
+    };
+  }
+};
+
+// src/providers/ProviderFactory.ts
+var ProviderFactory = class {
+  static createProvider(providerType, environment) {
+    const ProviderClass = this.providers.get(providerType);
+    if (!ProviderClass) {
+      throw new ConfigurationError(
+        `Unknown provider: ${providerType}. Supported providers: ${Array.from(this.providers.keys()).join(", ")}`,
+        providerType
+      );
+    }
+    return new ProviderClass(environment);
+  }
+  static getSupportedProviders() {
+    return Array.from(this.providers.keys());
+  }
+  static registerProvider(providerType, providerClass) {
+    this.providers.set(providerType, providerClass);
+  }
+  static isProviderSupported(providerType) {
+    return this.providers.has(providerType);
+  }
+};
+ProviderFactory.providers = /* @__PURE__ */ new Map([
+  ["cloudflare", CloudflareProvider],
+  ["groq", GroqProvider]
+]);
+
+// src/response/JsonParser.ts
+var JsonParser = class {
+  /**
+   * Enhanced JSON parsing with multiple fallback strategies
+   */
+  static parse(input, expectJson = false) {
+    if (!input || typeof input !== "string") {
+      return null;
+    }
+    if (expectJson && !this.looksLikeJson(input)) {
+      return null;
+    }
+    try {
+      return JSON.parse(input);
+    } catch {
+      const markdownJson = this.extractFromMarkdown(input);
+      if (markdownJson) {
+        try {
+          return JSON.parse(markdownJson);
+        } catch {
+        }
+      }
+      const genericCode = this.extractFromCodeBlock(input);
+      if (genericCode) {
+        try {
+          return JSON.parse(genericCode);
+        } catch {
+        }
+      }
+      const braceMatch = this.extractByBraces(input);
+      if (braceMatch) {
+        try {
+          return JSON.parse(braceMatch);
+        } catch {
+        }
+      }
+      const fixedJson = this.attemptJsonFixes(input);
+      if (fixedJson) {
+        try {
+          return JSON.parse(fixedJson);
+        } catch {
+        }
+      }
+      return null;
+    }
+  }
+  static looksLikeJson(input) {
+    const trimmed = input.trim();
+    return trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.includes('"');
+  }
+  static extractFromMarkdown(input) {
+    const match = input.match(/```json\s*(\{[\s\S]*?\})\s*```/);
+    return match ? match[1] : null;
+  }
+  static extractFromCodeBlock(input) {
+    const match = input.match(/```\s*(\{[\s\S]*?\})\s*```/);
+    return match ? match[1] : null;
+  }
+  static extractByBraces(input) {
+    const match = input.match(/\{[\s\S]*\}/);
+    return match ? match[0] : null;
+  }
+  static attemptJsonFixes(input) {
+    let fixed = input.trim();
+    fixed = fixed.replace(/,(\s*[}\]])/g, "$1");
+    fixed = fixed.replace(/'/g, '"');
+    fixed = fixed.replace(/"\s*:\s*"([^"]*?)"/g, (match, content) => {
+      const escaped = content.replace(/"/g, '\\"');
+      return `: "${escaped}"`;
+    });
+    fixed = fixed.replace(/\/\/.*$/gm, "");
+    fixed = fixed.replace(/\/\*[\s\S]*?\*\//g, "");
+    if (this.looksLikeJson(fixed)) {
+      return fixed;
+    }
+    return null;
+  }
+  /**
+   * Safely stringify any value to JSON
+   */
+  static stringify(value, pretty = false) {
+    try {
+      return pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+};
+
+// src/response/ResponseBuilder.ts
+var ResponseBuilder = class _ResponseBuilder {
+  constructor() {
+    this.content = "";
+    this.toolCalls = [];
+    this.rawResponse = null;
+    this.usage = {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0
+    };
+    this.jsonMode = false;
+  }
+  setContent(content) {
+    this.content = content;
+    return this;
+  }
+  setToolCalls(toolCalls) {
+    this.toolCalls = toolCalls;
+    return this;
+  }
+  setRawResponse(raw) {
+    this.rawResponse = raw;
+    return this;
+  }
+  setUsage(usage) {
+    this.usage = usage;
+    return this;
+  }
+  setJsonMode(jsonMode) {
+    this.jsonMode = jsonMode;
+    return this;
+  }
+  build() {
+    const isJson = this.toolCalls.length === 0 && (this.jsonMode || this.content.trim().startsWith("{"));
+    return {
+      content: this.content,
+      isJson,
+      tool_calls: this.toolCalls,
+      raw: this.rawResponse,
+      usage: this.usage,
+      json: () => JsonParser.parse(this.content, isJson)
+    };
+  }
+  static create() {
+    return new _ResponseBuilder();
+  }
+};
+
+// src/config/Configuration.ts
+var ConfigurationValidator = class {
+  static validateProvider(provider, environment) {
+    const config = this.providerConfigs.get(provider);
+    if (!config) {
+      throw new Error(`Unknown provider: ${provider}`);
+    }
+    this.validateEnvironmentVariables(provider, config, environment);
+  }
+  static validateModel(provider, model) {
+    const config = this.providerConfigs.get(provider);
+    if (!config || !config.modelValidation) {
+      return;
+    }
+    const validation = config.modelValidation;
+    if (validation.minLength && model.length < validation.minLength) {
+      throw new Error(
+        `Model name must be at least ${validation.minLength} characters long`
+      );
+    }
+    if (validation.maxLength && model.length > validation.maxLength) {
+      throw new Error(
+        `Model name must not exceed ${validation.maxLength} characters`
+      );
+    }
+    if (validation.pattern && !validation.pattern.test(model)) {
+      throw new Error(
+        `Model name does not match required pattern: ${validation.pattern}`
+      );
+    }
+  }
+  static validateOptions(provider, options) {
+    const config = this.providerConfigs.get(provider);
+    if (!config) {
+      return;
+    }
+    if ("temperature" in options) {
+      const temp = options.temperature;
+      if (typeof temp !== "number" || temp < 0 || temp > 2) {
+        throw new Error("Temperature must be a number between 0 and 2");
+      }
+    }
+    if ("max_tokens" in options) {
+      const tokens = options.max_tokens;
+      if (typeof tokens !== "number" || tokens <= 0) {
+        throw new Error("Max tokens must be a positive number");
+      }
+    }
+  }
+  static getProviderConfig(provider) {
+    return this.providerConfigs.get(provider);
+  }
+  static registerProviderConfig(provider, config) {
+    this.providerConfigs.set(provider, config);
+  }
+  static validateEnvironmentVariables(provider, config, environment) {
+    const missing = config.requiredEnvVars.filter((key) => !environment[key]);
+    if (missing.length > 0) {
+      throw new Error(
+        `Missing required environment variables for ${provider}: ${missing.join(", ")}`
+      );
+    }
+  }
+};
+ConfigurationValidator.providerConfigs = /* @__PURE__ */ new Map([
+  [
+    "cloudflare",
+    {
+      requiredEnvVars: ["AI"],
+      optionalEnvVars: [],
+      defaultOptions: {},
+      supportedFeatures: {
+        jsonMode: true,
+        tools: true,
+        streaming: false
+      }
+    }
+  ],
+  [
+    "groq",
+    {
+      requiredEnvVars: ["GROQ_API_KEY"],
+      optionalEnvVars: [],
+      defaultOptions: {
+        temperature: 0.7,
+        max_tokens: 1024
+      },
+      supportedFeatures: {
+        jsonMode: true,
+        tools: true,
+        streaming: true
+      }
+    }
+  ]
+]);
+var RuntimeConfigManager = class {
+  static getConfig() {
+    return { ...this.defaultConfig };
+  }
+  static updateConfig(updates) {
+    this.defaultConfig = this.deepMerge(this.defaultConfig, updates);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+        result[key] = this.deepMerge(result[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+};
+RuntimeConfigManager.defaultConfig = {
+  timeout: 3e4,
+  retries: {
+    maxAttempts: 3,
+    baseDelay: 1e3,
+    maxDelay: 1e4
+  },
+  caching: {
+    enabled: false,
+    ttl: 3e5
+    // 5 minutes
+  },
+  logging: {
+    enabled: true,
+    level: "info"
+  }
+};
+
+// src/errors/RetryHandler.ts
+var RetryHandler = class {
+  static async executeWithRetry(operation, config = {}, context) {
+    const fullConfig = { ...this.defaultConfig, ...config };
+    let lastError;
+    for (let attempt = 0; attempt <= fullConfig.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt === fullConfig.maxRetries) {
+          break;
+        }
+        if (!this.shouldRetry(error, fullConfig)) {
+          break;
+        }
+        const delay2 = this.calculateDelay(attempt, fullConfig);
+        if (context) {
+          console.warn(
+            `${context} - Attempt ${attempt + 1}/${fullConfig.maxRetries + 1} failed. Retrying in ${delay2}ms...`
+          );
+        }
+        await this.sleep(delay2);
+      }
+    }
+    throw lastError;
+  }
+  static shouldRetry(error, config) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorString = errorMessage.toLowerCase();
+    if (config.retryableErrors.some(
+      (retryableError) => errorString.includes(retryableError.toLowerCase())
+    )) {
+      return true;
+    }
+    if (error && typeof error === "object" && "status" in error && typeof error.status === "number") {
+      return config.retryableStatusCodes.includes(error.status);
+    }
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      return true;
+    }
+    return false;
+  }
+  static calculateDelay(attempt, config) {
+    const exponentialDelay = config.baseDelay * Math.pow(config.backoffFactor, attempt);
+    const jitter = Math.random() * 0.1 * exponentialDelay;
+    return Math.min(exponentialDelay + jitter, config.maxDelay);
+  }
+  static sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+RetryHandler.defaultConfig = {
+  maxRetries: 3,
+  baseDelay: 1e3,
+  maxDelay: 1e4,
+  backoffFactor: 2,
+  retryableErrors: ["1031", "500", "502", "503", "504", "timeout", "network"],
+  retryableStatusCodes: [500, 502, 503, 504, 429]
+};
+var ErrorHandler = class {
+  static wrapProviderError(error, provider, context) {
+    const contextMessage = context ? ` (${context})` : "";
+    if (error instanceof Error) {
+      return new Error(
+        `[${provider.toUpperCase()}]${contextMessage} ${error.message}`
+      );
+    }
+    if (typeof error === "string") {
+      return new Error(`[${provider.toUpperCase()}]${contextMessage} ${error}`);
+    }
+    return new Error(
+      `[${provider.toUpperCase()}]${contextMessage} Unknown error occurred`
+    );
+  }
+  static isNetworkError(error) {
+    return error instanceof TypeError && (error.message.includes("fetch") || error.message.includes("network") || error.message.includes("ECONNREFUSED"));
+  }
+  static isTimeoutError(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return errorMessage.toLowerCase().includes("timeout");
+  }
+  static isRateLimitError(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return errorMessage.toLowerCase().includes("rate limit") || Boolean(
+      error && typeof error === "object" && "status" in error && error.status === 429
+    );
+  }
+};
+
+// src/ModelRunner.ts
+var ModelRunner = class {
+  constructor(environment) {
+    this.environment = environment;
+  }
+  async run({
+    messages,
+    model,
+    jsonMode = false,
+    options = {}
+  }) {
+    const { provider, model: modelName } = model;
+    try {
+      this.validateInputs(provider, modelName, options);
+      const providerInstance = ProviderFactory.createProvider(
+        provider,
+        this.environment
+      );
+      this.validateCapabilities(providerInstance, jsonMode, options);
+      const response = await RetryHandler.executeWithRetry(
+        () => providerInstance.execute({
+          messages,
+          jsonMode,
+          options,
+          model: modelName
+        }),
+        RuntimeConfigManager.getConfig().retries,
+        `ModelRunner execution with ${provider}`
+      );
+      return ResponseBuilder.create().setContent(response.content).setToolCalls(response.toolCalls).setRawResponse(response.raw).setUsage(response.usage).setJsonMode(jsonMode).build();
+    } catch (error) {
+      throw ErrorHandler.wrapProviderError(error, provider, "ModelRunner.run");
+    }
+  }
+  /**
+   * Get supported providers
+   */
+  static getSupportedProviders() {
+    return ProviderFactory.getSupportedProviders();
+  }
+  /**
+   * Check if a provider supports specific features
+   */
+  static getProviderCapabilities(provider) {
+    const config = ConfigurationValidator.getProviderConfig(provider);
+    return config?.supportedFeatures;
+  }
+  /**
+   * Update runtime configuration
+   */
+  static updateRuntimeConfig(config) {
+    RuntimeConfigManager.updateConfig(config);
+  }
+  /**
+   * Validate inputs before processing
+   */
+  validateInputs(provider, model, options) {
+    ConfigurationValidator.validateProvider(provider, this.environment);
+    ConfigurationValidator.validateModel(provider, model);
+    ConfigurationValidator.validateOptions(provider, options);
+  }
+  /**
+   * Validate that the provider supports the requested features
+   */
+  validateCapabilities(provider, jsonMode, options) {
+    if (jsonMode && !provider.supportsJsonMode()) {
+      throw new ConfigurationError(
+        `Provider ${provider.providerType} does not support JSON mode`,
+        provider.providerType
+      );
+    }
+    if (options?.tools && !provider.supportsTools()) {
+      throw new ConfigurationError(
+        `Provider ${provider.providerType} does not support tools`,
+        provider.providerType
+      );
+    }
+  }
+};
+export {
+  ConfigurationError,
+  ModelRunner,
+  ProviderError,
+  cloudflareAIModel,
+  groqAIModel
+};
+//# sourceMappingURL=index.js.map