@illuma-ai/agents 1.0.81

package/src/tools/search/utils.ts

@@ -0,0 +1,79 @@
+/* eslint-disable no-console */
+
+import type * as t from './types';
+
+/**
+ * Singleton instance of the default logger
+ */
+let defaultLoggerInstance: t.Logger | null = null;
+
+/**
+ * Creates a default logger that maps to console methods
+ * Uses a singleton pattern to avoid creating multiple instances
+ * @returns A default logger that implements the Logger interface
+ */
+export const createDefaultLogger = (): t.Logger => {
+  if (!defaultLoggerInstance) {
+    defaultLoggerInstance = {
+      error: console.error,
+      warn: console.warn,
+      info: console.info,
+      debug: console.debug,
+    } as t.Logger;
+  }
+  return defaultLoggerInstance;
+};
+
+export const fileExtRegex =
+  /\.(pdf|jpe?g|png|gif|svg|webp|bmp|ico|tiff?|avif|heic|doc[xm]?|xls[xm]?|ppt[xm]?|zip|rar|mp[34]|mov|avi|wav)(?:\?.*)?$/i;
+
+export const getDomainName = (
+  link: string,
+  metadata?: t.ScrapeMetadata,
+  logger?: t.Logger
+): string | undefined => {
+  try {
+    const url = metadata?.sourceURL ?? metadata?.url ?? (link || '');
+    const domain = new URL(url).hostname.replace(/^www\./, '');
+    if (domain) {
+      return domain;
+    }
+  } catch (e) {
+    // URL parsing failed
+    if (logger) {
+      logger.error('Error parsing URL:', e);
+    } else {
+      console.error('Error parsing URL:', e);
+    }
+  }
+
+  return;
+};
+
+export function getAttribution(
+  link: string,
+  metadata?: t.ScrapeMetadata,
+  logger?: t.Logger
+): string | undefined {
+  if (!metadata) return getDomainName(link, metadata, logger);
+
+  const twitterSite = metadata['twitter:site'];
+  const twitterSiteFormatted =
+    typeof twitterSite === 'string' ? twitterSite.replace(/^@/, '') : undefined;
+
+  const possibleAttributions = [
+    metadata.ogSiteName,
+    metadata['og:site_name'],
+    metadata.title?.split('|').pop()?.trim(),
+    twitterSiteFormatted,
+  ];
+
+  const attribution = possibleAttributions.find(
+    (attr) => attr != null && typeof attr === 'string' && attr.trim() !== ''
+  );
+  if (attribution != null) {
+    return attribution;
+  }
+
+  return getDomainName(link, metadata, logger);
+}

package/src/types/graph.test.ts

@@ -0,0 +1,218 @@
+// src/types/graph.test.ts
+import type {
+  StructuredOutputConfig,
+  StructuredOutputMode,
+  AgentInputs,
+  BaseGraphState,
+} from './graph';
+import type { BaseMessage } from '@langchain/core/messages';
+
+/**
+ * Type-level tests to ensure StructuredOutputConfig interface is correctly defined.
+ * These tests don't run at runtime but will fail at compile time if types are wrong.
+ */
+describe('StructuredOutputConfig type', () => {
+  describe('type compatibility', () => {
+    it('should accept minimal configuration', () => {
+      const config: StructuredOutputConfig = {
+        schema: { type: 'object' },
+      };
+      expect(config.schema).toBeDefined();
+    });
+
+    it('should accept full configuration', () => {
+      const config: StructuredOutputConfig = {
+        schema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            value: { type: 'number' },
+          },
+          required: ['name'],
+        },
+        name: 'TestSchema',
+        description: 'A test schema for structured output',
+        mode: 'auto',
+        strict: true,
+        handleErrors: true,
+        maxRetries: 3,
+        includeRaw: false,
+      };
+
+      expect(config.schema).toBeDefined();
+      expect(config.name).toBe('TestSchema');
+      expect(config.description).toBe('A test schema for structured output');
+      expect(config.mode).toBe('auto');
+      expect(config.strict).toBe(true);
+      expect(config.handleErrors).toBe(true);
+      expect(config.maxRetries).toBe(3);
+      expect(config.includeRaw).toBe(false);
+    });
+
+    it('should accept all valid mode values', () => {
+      const modes: StructuredOutputMode[] = ['auto', 'tool', 'provider'];
+
+      for (const mode of modes) {
+        const config: StructuredOutputConfig = {
+          schema: { type: 'string' },
+          mode,
+        };
+        expect(config.mode).toBe(mode);
+      }
+    });
+
+    it('should make all fields except schema optional', () => {
+      const minimalConfig: StructuredOutputConfig = {
+        schema: { type: 'boolean' },
+      };
+
+      // These should all be undefined for minimal config
+      expect(minimalConfig.name).toBeUndefined();
+      expect(minimalConfig.description).toBeUndefined();
+      expect(minimalConfig.mode).toBeUndefined();
+      expect(minimalConfig.strict).toBeUndefined();
+      expect(minimalConfig.handleErrors).toBeUndefined();
+      expect(minimalConfig.maxRetries).toBeUndefined();
+      expect(minimalConfig.includeRaw).toBeUndefined();
+    });
+  });
+
+  describe('schema property types', () => {
+    it('should accept object schema', () => {
+      const config: StructuredOutputConfig = {
+        schema: {
+          type: 'object',
+          properties: {
+            nested: {
+              type: 'object',
+              properties: {
+                value: { type: 'string' },
+              },
+            },
+          },
+        },
+      };
+      expect(config.schema.type).toBe('object');
+    });
+
+    it('should accept array schema', () => {
+      const config: StructuredOutputConfig = {
+        schema: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'number' },
+            },
+          },
+        },
+      };
+      expect(config.schema.type).toBe('array');
+    });
+
+    it('should accept schema with enum', () => {
+      const config: StructuredOutputConfig = {
+        schema: {
+          type: 'string',
+          enum: ['option1', 'option2', 'option3'],
+        },
+      };
+      expect(config.schema.enum).toEqual(['option1', 'option2', 'option3']);
+    });
+
+    it('should accept schema with $ref', () => {
+      const config: StructuredOutputConfig = {
+        schema: {
+          $schema: 'http://json-schema.org/draft-07/schema#',
+          definitions: {
+            Address: {
+              type: 'object',
+              properties: {
+                street: { type: 'string' },
+                city: { type: 'string' },
+              },
+            },
+          },
+          type: 'object',
+          properties: {
+            address: { $ref: '#/definitions/Address' },
+          },
+        },
+      };
+      expect(config.schema.$schema).toBeDefined();
+    });
+  });
+});
+
+describe('AgentInputs with structuredOutput', () => {
+  it('should accept structuredOutput as optional field', () => {
+    const inputsWithout: Partial<AgentInputs> = {
+      agentId: 'agent-1',
+      provider: 'openai' as AgentInputs['provider'],
+    };
+    expect(inputsWithout.structuredOutput).toBeUndefined();
+
+    const inputsWith: Partial<AgentInputs> = {
+      agentId: 'agent-2',
+      provider: 'anthropic' as AgentInputs['provider'],
+      structuredOutput: {
+        schema: { type: 'object' },
+      },
+    };
+    expect(inputsWith.structuredOutput).toBeDefined();
+  });
+});
+
+describe('BaseGraphState with structuredResponse', () => {
+  it('should support structuredResponse field', () => {
+    const state: Partial<BaseGraphState> = {
+      messages: [],
+      structuredResponse: { result: 'success', data: [1, 2, 3] },
+    };
+    expect(state.structuredResponse).toEqual({
+      result: 'success',
+      data: [1, 2, 3],
+    });
+  });
+
+  it('should allow structuredResponse to be undefined', () => {
+    const state: Partial<BaseGraphState> = {
+      messages: [],
+    };
+    expect(state.structuredResponse).toBeUndefined();
+  });
+});
+
+describe('AgentInputs with summarizeCallback', () => {
+  it('should accept summarizeCallback as optional field', () => {
+    const inputsWithout: Partial<AgentInputs> = {
+      agentId: 'agent-1',
+      provider: 'openai' as AgentInputs['provider'],
+    };
+    expect(inputsWithout.summarizeCallback).toBeUndefined();
+
+    const inputsWith: Partial<AgentInputs> = {
+      agentId: 'agent-2',
+      provider: 'anthropic' as AgentInputs['provider'],
+      summarizeCallback: async (_messages: BaseMessage[]) => 'summary',
+    };
+    expect(inputsWith.summarizeCallback).toBeDefined();
+  });
+
+  it('should accept a valid callback function type', () => {
+    const mockCallback = async (messages: BaseMessage[]): Promise<string | undefined> => {
+      if (messages.length === 0) {
+        return undefined;
+      }
+      return `Summary of ${messages.length} messages`;
+    };
+
+    const inputs: Partial<AgentInputs> = {
+      agentId: 'agent-summarize',
+      provider: 'openai' as AgentInputs['provider'],
+      summarizeCallback: mockCallback,
+    };
+
+    expect(inputs.summarizeCallback).toBe(mockCallback);
+  });
+});