@bytexbyte/nxtlinq-ai-agent-web-development 0.1.1

package/src/legacy/core/utils/aitUtils.ts

@@ -0,0 +1,55 @@
+import { ethers } from 'ethers';
+import stringify from 'fast-json-stable-stringify';
+
+export interface AITMetadata {
+  permissions: string[];
+  issuedBy: string;
+}
+
+export interface CreateAITParams {
+  aitId: string;
+  controller: string;
+  serviceId: string;
+  metadataHash: string;
+  metadataCid: string;
+  isFromAIAgent?: boolean; // Identify if created by AI Agent
+  parentAITId?: string; // Parent AIT ID, if created by AI Agent
+}
+
+export const generateAITId = (address: string): string => {
+  const timestamp = Math.floor(Date.now() / 1000);
+  return `did:polygon:nxtlinq:${address}:${timestamp}`;
+};
+
+export const createAITMetadata = (permissions: string[], issuedBy: string): AITMetadata => {
+  return {
+    permissions,
+    issuedBy,
+  };
+};
+
+export const generateMetadataHash = (metadata: AITMetadata): string => {
+  const metadataStr = stringify(metadata);
+  return ethers.keccak256(ethers.toUtf8Bytes(metadataStr));
+};
+
+export const prepareAITCreation = (address: string, permissions: string[], serviceId: string, isFromAIAgent = false, parentAITId?: string) => {
+  const aitId = generateAITId(address);
+  const metadata = createAITMetadata(permissions, address);
+  const metadataHash = generateMetadataHash(metadata);
+
+  return {
+    aitId,
+    metadata,
+    metadataHash,
+    createAITParams: {
+      aitId,
+      controller: address,
+      serviceId,
+      metadataHash,
+      metadataCid: '', // Will be set after metadata upload
+      isFromAIAgent,
+      parentAITId,
+    }
+  };
+};

package/src/legacy/core/utils/ethersUtils.ts

@@ -0,0 +1,24 @@
+import { ethers } from 'ethers';
+
+/**
+ * Safely get ethers library instance
+ * Tries imported ethers first, then falls back to window.ethers
+ * @throws Error if ethers is not available
+ */
+export const getEthers = (): typeof ethers => {
+  // Try to use the imported ethers first (most common case)
+  if (ethers && typeof ethers === 'object') {
+    return ethers;
+  }
+
+  // Fallback: try to get from global window object (in case client site provides it)
+  if (typeof window !== 'undefined' && (window as any).ethers) {
+    return (window as any).ethers;
+  }
+
+  // Provide error message
+  console.error('[Nxtlinq SDK] Failed to get ethers library');
+  throw new Error(
+    'ethers library is not properly loaded. Please ensure ethers v6 is available.'
+  );
+};

package/src/legacy/core/utils/index.ts

@@ -0,0 +1,5 @@
+export const sleep = (ms: number) => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export { getEthers } from './ethersUtils';

package/src/legacy/core/utils/notificationUtils.ts

@@ -0,0 +1,64 @@
+export type NotificationType = 'success' | 'error' | 'warning' | 'info';
+
+export interface Notification {
+  show: boolean;
+  type: NotificationType;
+  message: string;
+  autoHide?: boolean;
+  duration?: number;
+}
+
+export const createNotification = (
+  type: NotificationType,
+  message: string,
+  duration = 5000
+): Notification => ({
+  show: true,
+  type,
+  message,
+  autoHide: true,
+  duration
+});
+
+export const getNotificationIcon = (type: NotificationType): string => {
+  switch (type) {
+    case 'success':
+      return '✅';
+    case 'error':
+      return '❌';
+    case 'warning':
+      return '⚠️';
+    default:
+      return 'ℹ️';
+  }
+};
+
+export const getNotificationStyles = (type: NotificationType) => {
+  const baseStyles = {
+    position: 'fixed' as const,
+    bottom: 20,
+    right: 20,
+    padding: '12px 24px',
+    borderRadius: 8,
+    zIndex: 2000,
+    fontWeight: 600,
+    boxShadow: '0 4px 12px rgba(0, 0, 0, 0.15)',
+    transition: 'all 0.3s ease',
+    display: 'flex',
+    alignItems: 'center',
+    gap: '12px',
+    minWidth: '300px',
+    maxWidth: '500px'
+  };
+
+  switch (type) {
+    case 'success':
+      return { ...baseStyles, background: '#4caf50', color: 'white' };
+    case 'error':
+      return { ...baseStyles, background: '#f44336', color: 'white' };
+    case 'warning':
+      return { ...baseStyles, background: '#ff9800', color: 'white' };
+    default:
+      return { ...baseStyles, background: '#2196f3', color: 'white' };
+  }
+}; 

package/src/legacy/core/utils/urlUtils.ts

@@ -0,0 +1,160 @@
+/**
+ * URL utility functions for detecting and converting URLs to clickable links
+ */
+
+import * as React from 'react';
+
+/**
+ * Regular expression to match Markdown-style links
+ * Matches [text](url) format
+ */
+const MARKDOWN_LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
+
+/**
+ * Regular expression to match URLs
+ * Supports http, https, ftp, and www protocols
+ */
+const URL_REGEX = /(https?:\/\/[^\s]+|www\.[^\s]+|[a-zA-Z0-9-]+\.[a-zA-Z]{2,}(?:\/[^\s]*)?)/g;
+
+/**
+ * Check if a string contains URLs
+ * @param text - The text to check
+ * @returns boolean indicating if URLs are found
+ */
+export const containsUrls = (text: string): boolean => {
+  return URL_REGEX.test(text);
+};
+
+/**
+ * Convert text with line breaks to JSX elements with <br/> tags
+ * @param text - The text containing line breaks
+ * @param keyPrefix - Prefix for React keys
+ * @returns Array of JSX elements and strings
+ */
+const convertLineBreaks = (text: string, keyPrefix: string = ''): (string | React.ReactElement)[] => {
+  const parts: (string | React.ReactElement)[] = [];
+  const lines = text.split('\n');
+  
+  lines.forEach((line, index) => {
+    if (index > 0) {
+      parts.push(React.createElement('br', { key: `${keyPrefix}-br-${index}` }));
+    }
+    if (line) {
+      parts.push(line);
+    }
+  });
+  
+  return parts;
+};
+
+/**
+ * Convert text with URLs to JSX elements with clickable links
+ * Supports both Markdown format [text](url) and plain URLs
+ * Also handles line breaks (\n)
+ * @param text - The text containing URLs
+ * @returns Array of JSX elements and strings
+ */
+export const convertUrlsToLinks = (text: string): (string | React.ReactElement)[] => {
+  const parts: (string | React.ReactElement)[] = [];
+  let lastIndex = 0;
+  let keyCounter = 0;
+
+  // First, find all markdown links and plain URLs
+  const items: Array<{ type: 'markdown' | 'url'; start: number; end: number; text?: string; url: string }> = [];
+
+  // Find markdown links
+  let markdownMatch;
+  MARKDOWN_LINK_REGEX.lastIndex = 0;
+  while ((markdownMatch = MARKDOWN_LINK_REGEX.exec(text)) !== null) {
+    items.push({
+      type: 'markdown',
+      start: markdownMatch.index,
+      end: markdownMatch.index + markdownMatch[0].length,
+      text: markdownMatch[1],
+      url: markdownMatch[2]
+    });
+  }
+
+  // Find plain URLs (but exclude those already matched as markdown links)
+  let urlMatch;
+  URL_REGEX.lastIndex = 0;
+  while ((urlMatch = URL_REGEX.exec(text)) !== null) {
+    const start = urlMatch.index;
+    const end = start + urlMatch[0].length;
+    
+    // Check if this URL is already part of a markdown link
+    const isPartOfMarkdown = items.some(item => 
+      item.type === 'markdown' && start >= item.start && end <= item.end
+    );
+    
+    if (!isPartOfMarkdown) {
+      items.push({
+        type: 'url',
+        start,
+        end,
+        url: urlMatch[0]
+      });
+    }
+  }
+
+  // Sort items by start position
+  items.sort((a, b) => a.start - b.start);
+
+  // Build the result
+  items.forEach(item => {
+    // Add text before this item (with line breaks)
+    if (item.start > lastIndex) {
+      const textBefore = text.slice(lastIndex, item.start);
+      const textBeforeParts = convertLineBreaks(textBefore, `text-${keyCounter}`);
+      parts.push(...textBeforeParts);
+      keyCounter++;
+    }
+
+    // Create clickable link
+    const href = item.url.startsWith('http') ? item.url : `https://${item.url}`;
+    const displayText = item.type === 'markdown' ? item.text : item.url;
+    
+    parts.push(
+      React.createElement('a', {
+        key: `link-${keyCounter++}`,
+        href: href,
+        target: '_blank',
+        rel: 'noopener noreferrer',
+        style: {
+          color: '#007bff',
+          textDecoration: 'underline',
+          cursor: 'pointer'
+        },
+        className: 'ai-agent-url-link',
+        onClick: (e: React.MouseEvent) => {
+          e.preventDefault(); // Prevent default browser behavior
+          e.stopPropagation();
+          window.open(href, '_blank', 'noopener,noreferrer');
+        }
+      }, displayText)
+    );
+
+    lastIndex = item.end;
+  });
+
+  // Add remaining text after the last link (with line breaks)
+  if (lastIndex < text.length) {
+    const textAfter = text.slice(lastIndex);
+    const textAfterParts = convertLineBreaks(textAfter, `text-${keyCounter}`);
+    parts.push(...textAfterParts);
+  }
+
+  return parts.length > 0 ? parts : convertLineBreaks(text, 'default');
+};
+
+/**
+ * Simple function to wrap URLs in anchor tags for basic HTML rendering
+ * @param text - The text containing URLs
+ * @returns HTML string with clickable links
+ */
+export const convertUrlsToHtml = (text: string): string => {
+  return text.replace(URL_REGEX, (url) => {
+    const href = url.startsWith('http') ? url : `https://${url}`;
+    return `<a href="${href}" target="_blank" rel="noopener noreferrer" style="color: #007bff; text-decoration: underline; cursor: pointer;">${url}</a>`;
+  });
+};

package/src/legacy/core/utils/walletTextUtils.ts

@@ -0,0 +1,26 @@
+/**
+ * Adilas Service ID constant
+ */
+export const ADILAS_SERVICE_ID = 'e48fc2b9-a7d1-49e3-85cb-9d621a0bf774';
+
+/**
+ * Check if the given serviceId is the Adilas service
+ */
+export const isAdilasService = (serviceId: string | undefined | null): boolean => {
+  return serviceId ? serviceId.trim() === ADILAS_SERVICE_ID : false;
+};
+
+/**
+ * Replace "wallet" with "account" in text when serviceId is Adilas service
+ * Preserves the original case of the word
+ */
+export const getWalletText = (defaultText: string, serviceId: string | undefined | null): string => {
+  if (!isAdilasService(serviceId)) return defaultText;
+  
+  // Replace wallet with account, preserving case
+  return defaultText.replace(/\bwallet\b/gi, (match) => {
+    // Preserve original case: 'Wallet' -> 'Account', 'wallet' -> 'account'
+    return match.charAt(0) === 'W' ? 'Account' : 'account';
+  });
+};
+

package/src/legacy/core/utils/walletUtils.ts

@@ -0,0 +1,53 @@
+import { ethers } from 'ethers';
+import metakeepClient from '../metakeepClient';
+import { getEthers } from './ethersUtils';
+
+export interface WalletConnectionResult {
+  address: string;
+  signer: ethers.JsonRpcSigner;
+}
+
+export const connectWallet = async (): Promise<WalletConnectionResult> => {
+  if (typeof window === 'undefined') {
+    throw new Error('Web3 is not available in server-side rendering');
+  }
+
+  getEthers();
+
+  const web3Provider = await metakeepClient.ethereum;
+  if (!web3Provider) {
+    throw new Error('Web3 provider not available');
+  }
+
+  await web3Provider.enable();
+
+  // ethers v6: Use BrowserProvider instead of Web3Provider
+  const ethersProvider = new ethers.BrowserProvider(web3Provider);
+
+  // ethers v6: getSigner() and getAddress() are now async
+  const signer = await ethersProvider.getSigner();
+  const address = await signer.getAddress();
+
+  localStorage.setItem('walletAddress', address);
+
+  return { address, signer };
+};
+
+export const disconnectWallet = (): void => {
+  localStorage.removeItem('walletAddress');
+};
+
+export const getStoredWalletAddress = (): string | null => {
+  return localStorage.getItem('walletAddress');
+};
+
+export const validateToken = (token: string, expectedAddress: string): boolean => {
+  try {
+    const payload = JSON.parse(atob(token.split('.')[1]));
+    const address = payload.address;
+    return address === expectedAddress;
+  } catch (error) {
+    console.error('Error parsing token:', error);
+    return false;
+  }
+}; 

package/src/legacy/index.ts

@@ -0,0 +1,35 @@
+export { createNxtlinqApi, setApiHosts, getAiAgentApiHost } from './api/nxtlinq-api';
+export { startVoiceSession, createVoiceApi } from './api/voice';
+export type * from './api/voice';
+
+export { useDraggable } from './core/lib/useDraggable';
+export { default as useLocalStorage } from './core/lib/useLocalStorage';
+export { default as useSessionStorage } from './core/lib/useSessionStorage';
+export { useResizable } from './core/lib/useResizable';
+export type { ResizeCorner } from './core/lib/useResizable';
+export { synthesizeSpeechToBuffer } from './core/lib/textToSpeech';
+export { useSpeechToTextFromMic } from './core/lib/useSpeechToTextFromMic';
+export { useVoiceMode } from './core/lib/useVoiceMode';
+
+export { default as metakeepClient } from './core/metakeepClient';
+export { getEthers, sleep } from './core/utils';
+export * as walletTextUtils from './core/utils/walletTextUtils';
+export {
+  connectWallet,
+  disconnectWallet,
+  validateToken,
+} from './core/utils/walletUtils';
+export {
+  createAITMetadata,
+  generateAITId,
+  prepareAITCreation,
+} from './core/utils/aitUtils';
+export {
+  createNotification,
+  getNotificationIcon,
+} from './core/utils/notificationUtils';
+export {
+  containsUrls,
+  convertUrlsToLinks,
+  convertUrlsToHtml,
+} from './core/utils/urlUtils';

package/src/ports/createWebPlatformPorts.ts

@@ -0,0 +1,44 @@
+import type { HttpPort, PlatformPorts, StoragePort, WebRTCPort } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import {
+  createBrowserStoragePort,
+  createBrowserWebRTCPort,
+  createDefaultHttpPort,
+} from '@bytexbyte/nxtlinq-ai-agent-core-development';
+
+export type CreateWebPlatformPortsOptions = {
+  /** Override default `localStorage` port. */
+  storage?: StoragePort;
+  fetchImpl?: typeof fetch;
+  getTimezone?: () => string;
+  /** Pre-built WebRTC port (overrides browser default). */
+  webrtc?: WebRTCPort;
+  /** Set `false` to disable voice (no WebRTC port). */
+  enableWebRTC?: boolean;
+};
+
+function resolveHttpPort(fetchImpl?: typeof fetch): HttpPort {
+  if (!fetchImpl) return createDefaultHttpPort();
+  return { fetch: fetchImpl };
+}
+
+export function createWebPlatformPorts(
+  options: CreateWebPlatformPortsOptions = {},
+): PlatformPorts {
+  const enableWebRTC = options.enableWebRTC !== false;
+  return {
+    storage: options.storage ?? createBrowserStoragePort(),
+    http: resolveHttpPort(options.fetchImpl),
+    webrtc: enableWebRTC
+      ? (options.webrtc ?? createBrowserWebRTCPort())
+      : undefined,
+    getTimezone:
+      options.getTimezone
+      ?? (() => {
+        try {
+          return Intl.DateTimeFormat().resolvedOptions().timeZone;
+        } catch {
+          return 'UTC';
+        }
+      }),
+  };
+}

package/src/utils/fileToAttachment.ts

@@ -0,0 +1,32 @@
+import type { Attachment } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+
+function readFileAsDataUri(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (typeof reader.result === 'string') {
+        resolve(reader.result);
+        return;
+      }
+      reject(new Error('fileToAttachment: failed to read file'));
+    };
+    reader.onerror = () => reject(reader.error ?? new Error('fileToAttachment: read error'));
+    reader.readAsDataURL(file);
+  });
+}
+
+function attachmentType(mimeType: string): Attachment['type'] {
+  return mimeType.startsWith('image/') ? 'image' : 'file';
+}
+
+/** Build an {@link Attachment} from a browser {@link File}. */
+export async function fileToAttachment(file: File): Promise<Attachment> {
+  const url = await readFileAsDataUri(file);
+  return {
+    type: attachmentType(file.type || 'application/octet-stream'),
+    url,
+    name: file.name,
+    mimeType: file.type || 'application/octet-stream',
+    size: file.size,
+  };
+}

package/src/voice/useVoiceSilenceCommit.ts

@@ -0,0 +1,84 @@
+import type { VoiceSession, VoiceStatus } from '@bytexbyte/nxtlinq-ai-agent-core-development';
+import { useCallback, useRef } from 'react';
+import { ASSISTANT_MIC_HOLD_STATUSES } from './voiceMicConstants';
+import {
+  MIC_BARGE_IN_RMS_THRESHOLD,
+  MIC_SILENCE_COMMIT_MS,
+  MIC_SILENCE_POLL_MS,
+  MIC_SPEECH_RMS_THRESHOLD,
+} from './ws/voiceSilenceConstants';
+
+export function useVoiceSilenceCommit(
+  getSession: () => VoiceSession | null,
+  onMutedAfterCommit: () => void,
+  voiceStatus: VoiceStatus,
+) {
+  const lastSpeechAtRef = useRef(0);
+  const hadSpeechRef = useRef(false);
+  const commitInFlightRef = useRef(false);
+  const skipCommitOnMuteRef = useRef(false);
+  const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const voiceStatusRef = useRef(voiceStatus);
+  voiceStatusRef.current = voiceStatus;
+  const onMutedAfterCommitRef = useRef(onMutedAfterCommit);
+  onMutedAfterCommitRef.current = onMutedAfterCommit;
+
+  const clearPoll = useCallback(() => {
+    if (pollRef.current) {
+      clearInterval(pollRef.current);
+      pollRef.current = null;
+    }
+  }, []);
+
+  const tryCommit = useCallback((reason: 'silence' | 'manual') => {
+    const session = getSession();
+    if (commitInFlightRef.current) return;
+    if (!hadSpeechRef.current) {
+      session?.clearInputAudio?.();
+      return;
+    }
+    commitInFlightRef.current = true;
+    hadSpeechRef.current = false;
+    session?.commitInputAudio?.();
+    if (reason === 'silence') {
+      skipCommitOnMuteRef.current = true;
+      onMutedAfterCommitRef.current();
+    }
+    queueMicrotask(() => { commitInFlightRef.current = false; });
+  }, [getSession]);
+
+  const startPoll = useCallback(() => {
+    clearPoll();
+    pollRef.current = setInterval(() => {
+      if (commitInFlightRef.current || !hadSpeechRef.current) return;
+      if (Date.now() - lastSpeechAtRef.current < MIC_SILENCE_COMMIT_MS) return;
+      tryCommit('silence');
+    }, MIC_SILENCE_POLL_MS);
+  }, [clearPoll, tryCommit]);
+
+  const resetTurn = useCallback(() => {
+    hadSpeechRef.current = false;
+    lastSpeechAtRef.current = Date.now();
+    getSession()?.clearInputAudio?.();
+  }, [getSession]);
+
+  const onSpeechRms = useCallback((rms: number) => {
+    const threshold = ASSISTANT_MIC_HOLD_STATUSES.has(voiceStatusRef.current)
+      ? MIC_BARGE_IN_RMS_THRESHOLD
+      : MIC_SPEECH_RMS_THRESHOLD;
+    if (rms >= threshold) {
+      lastSpeechAtRef.current = Date.now();
+      hadSpeechRef.current = true;
+    }
+  }, []);
+
+  const consumeSkipCommitOnMute = useCallback(() => {
+    const skip = skipCommitOnMuteRef.current;
+    skipCommitOnMuteRef.current = false;
+    return skip;
+  }, []);
+
+  const hasHadSpeech = useCallback(() => hadSpeechRef.current, []);
+
+  return { startPoll, clearPoll, resetTurn, onSpeechRms, tryCommit, consumeSkipCommitOnMute, hasHadSpeech };
+}