@ulam/halohalo 0.3.2 → 0.3.3

package/angular.js

@@ -1,102 +1,102 @@
-/**
- * @ulam/halohalo/angular: Angular adapter
- *
- * Injectable services wrapping the vanilla halohalo core with Angular signal
- * reactivity. Provide once at the application root via provideHalohalo().
- */
-import { Injectable, signal, computed } from '@angular/core'
-import { createCompletion } from './createCompletion.js'
-import { createProviderConfig } from './createProviderConfig.js'
-
-/**
- * Service for AI completions. Each inject() call gets its own completion
- * instance; loading/animating state is per-instance.
- *
- * Usage:
- *   private completion = inject(CompletionService)
- *
- *   await this.completion.complete({ prompt: 'Rewrite for mobile.' })
- *   // this.completion.loading() is true while running
- */
-@Injectable()
-export class CompletionService {
-  #instance = createCompletion()
-  #loading = signal(false)
-  #animating = signal(false)
-
-  loading = computed(() => this.#loading())
-  animating = computed(() => this.#animating())
-
-  constructor() {
-    this.#instance.subscribe(({ loading, animating }) => {
-      this.#loading.set(loading)
-      this.#animating.set(animating)
-    })
-  }
-
-  complete(options) {
-    return this.#instance.complete(options)
-  }
-
-  cancel() {
-    this.#instance.cancel()
-  }
-
-  ngOnDestroy() {
-    this.#instance.cancel()
-  }
-}
-
-/**
- * Service for AI provider and model configuration. One config store per application.
- *
- * Usage:
- *   private providerConfig = inject(ProviderConfigService)
- *
- *   this.providerConfig.setProvider('openai')
- *   const current = this.providerConfig.provider()   // Signal<string>
- */
-@Injectable({ providedIn: 'root' })
-export class ProviderConfigService {
-  #config = createProviderConfig()
-  #provider = signal(this.#config.provider)
-  #models = signal(this.#config.models)
-  #mode = signal(this.#config.mode)
-
-  provider = computed(() => this.#provider())
-  models = computed(() => this.#models())
-  mode = computed(() => this.#mode())
-  providers = this.#config.providers
-
-  constructor() {
-    this.#config.subscribe(() => {
-      this.#provider.set(this.#config.provider)
-      this.#models.set(this.#config.models)
-      this.#mode.set(this.#config.mode)
-    })
-  }
-
-  setProvider(id) { this.#config.setProvider(id) }
-  setModel(pid, mid) { this.#config.setModel(pid, mid) }
-  setMode(v) { this.#config.setMode(v) }
-  setKey(pid, v) { return this.#config.setKey(pid, v) }
-  getKey(pid) { return this.#config.getKey(pid) }
-  getModel(pid) { return this.#config.getModel(pid) }
-  getLabel(pid) { return this.#config.getLabel(pid) }
-}
-
-/**
- * Standalone provider function. Use in bootstrapApplication() or as a
- * component-level provider when you need scoped completion instances.
- *
- * App-level (shared singleton):
- *   bootstrapApplication(AppComponent, {
- *     providers: [provideHalohalo()]
- *   })
- *
- * Component-level (scoped instance):
- *   @Component({ providers: [CompletionService] })
- */
-export function provideHalohalo() {
-  return [ProviderConfigService, CompletionService]
-}
+/**
+ * @ulam/halohalo/angular: Angular adapter
+ *
+ * Injectable services wrapping the vanilla halohalo core with Angular signal
+ * reactivity. Provide once at the application root via provideHalohalo().
+ */
+import { Injectable, signal, computed } from '@angular/core'
+import { createCompletion } from './createCompletion.js'
+import { createProviderConfig } from './createProviderConfig.js'
+
+/**
+ * Service for AI completions. Each inject() call gets its own completion
+ * instance; loading/animating state is per-instance.
+ *
+ * Usage:
+ *   private completion = inject(CompletionService)
+ *
+ *   await this.completion.complete({ prompt: 'Rewrite for mobile.' })
+ *   // this.completion.loading() is true while running
+ */
+@Injectable()
+export class CompletionService {
+  #instance = createCompletion()
+  #loading = signal(false)
+  #animating = signal(false)
+
+  loading = computed(() => this.#loading())
+  animating = computed(() => this.#animating())
+
+  constructor() {
+    this.#instance.subscribe(({ loading, animating }) => {
+      this.#loading.set(loading)
+      this.#animating.set(animating)
+    })
+  }
+
+  complete(options) {
+    return this.#instance.complete(options)
+  }
+
+  cancel() {
+    this.#instance.cancel()
+  }
+
+  ngOnDestroy() {
+    this.#instance.cancel()
+  }
+}
+
+/**
+ * Service for AI provider and model configuration. One config store per application.
+ *
+ * Usage:
+ *   private providerConfig = inject(ProviderConfigService)
+ *
+ *   this.providerConfig.setProvider('openai')
+ *   const current = this.providerConfig.provider()   // Signal<string>
+ */
+@Injectable({ providedIn: 'root' })
+export class ProviderConfigService {
+  #config = createProviderConfig()
+  #provider = signal(this.#config.provider)
+  #models = signal(this.#config.models)
+  #mode = signal(this.#config.mode)
+
+  provider = computed(() => this.#provider())
+  models = computed(() => this.#models())
+  mode = computed(() => this.#mode())
+  providers = this.#config.providers
+
+  constructor() {
+    this.#config.subscribe(() => {
+      this.#provider.set(this.#config.provider)
+      this.#models.set(this.#config.models)
+      this.#mode.set(this.#config.mode)
+    })
+  }
+
+  setProvider(id) { this.#config.setProvider(id) }
+  setModel(pid, mid) { this.#config.setModel(pid, mid) }
+  setMode(v) { this.#config.setMode(v) }
+  setKey(pid, v) { return this.#config.setKey(pid, v) }
+  getKey(pid) { return this.#config.getKey(pid) }
+  getModel(pid) { return this.#config.getModel(pid) }
+  getLabel(pid) { return this.#config.getLabel(pid) }
+}
+
+/**
+ * Standalone provider function. Use in bootstrapApplication() or as a
+ * component-level provider when you need scoped completion instances.
+ *
+ * App-level (shared singleton):
+ *   bootstrapApplication(AppComponent, {
+ *     providers: [provideHalohalo()]
+ *   })
+ *
+ * Component-level (scoped instance):
+ *   @Component({ providers: [CompletionService] })
+ */
+export function provideHalohalo() {
+  return [ProviderConfigService, CompletionService]
+}

package/connectivity.js

@@ -1,17 +1,17 @@
-/**
- * Probes a list of endpoints in parallel to check network reachability.
- *
- * @param {Array<{ label: string, url: string }>} probes
- * @param {number} [timeoutMs=4000]
- * @returns {Promise<Array<{ label: string, ok: boolean }>>}
- */
-export async function checkConnectivity(probes, timeoutMs = 4000) {
-  const results = await Promise.allSettled(
-    probes.map(p =>
-      fetch(p.url, { method: 'HEAD', mode: 'no-cors', signal: AbortSignal.timeout(timeoutMs) })
-        .then(() => ({ label: p.label, ok: true }))
-        .catch(() => ({ label: p.label, ok: false }))
-    )
-  )
-  return results.map(r => r.value || r.reason)
-}
+/**
+ * Probes a list of endpoints in parallel to check network reachability.
+ *
+ * @param {Array<{ label: string, url: string }>} probes
+ * @param {number} [timeoutMs=4000]
+ * @returns {Promise<Array<{ label: string, ok: boolean }>>}
+ */
+export async function checkConnectivity(probes, timeoutMs = 4000) {
+  const results = await Promise.allSettled(
+    probes.map(p =>
+      fetch(p.url, { method: 'HEAD', mode: 'no-cors', signal: AbortSignal.timeout(timeoutMs) })
+        .then(() => ({ label: p.label, ok: true }))
+        .catch(() => ({ label: p.label, ok: false }))
+    )
+  )
+  return results.map(r => r.value || r.reason)
+}

package/createCompletion.js

@@ -1,113 +1,113 @@
-import { callProvider, callAnthropicWithTools } from './fetch.js'
-import { AiApiError } from './providers.js'
-
-const DEFAULT_TYPEWRITER = { tickMs: 33, minCharsPerTick: 2, charDivisor: 40 }
-
-/**
- * Vanilla completion runner. No React required.
- * Returns { complete(options), cancel() } plus a subscribe() for state changes.
- *
- * State: { loading: boolean, animating: boolean }
- *
- * options for complete():
- *   provider, model, key, prompt, maxTokens: for standard completions
- *   agentOptions: { system, tools, messages, maxTurns, onToolCall }: for agentic
- *   onResult(fields)       : called with parsed result after completion
- *   onError(error)         : called with AiApiError on failure
- *   parseResponse(text)    : maps raw text to result fields object
- *   typewriter             : { tickMs, minCharsPerTick, charDivisor } or false
- *   onAnimate(field, text) : called each tick with field + current text slice
- *   onAnimateDone()        : called when typewriter finishes
- */
-export function createCompletion() {
-  let loading = false
-  let animating = false
-  let timer = null
-  const listeners = new Set()
-  const notify = () => listeners.forEach(fn => fn({ loading, animating }))
-
-  function runTypewriter(fields, { typewriter, onAnimate, onAnimateDone }) {
-    clearTimeout(timer)
-    const { tickMs, minCharsPerTick, charDivisor } = { ...DEFAULT_TYPEWRITER, ...typewriter }
-
-    const entries = Object.entries(fields).filter(([, v]) => typeof v === 'string' && v.length > 0)
-    if (!entries.length) {
-      animating = false
-      notify()
-      onAnimateDone?.()
-      return
-    }
-
-    const total = entries.reduce((sum, [, v]) => sum + v.length, 0)
-    const charsPerTick = Math.max(minCharsPerTick, Math.ceil(total / charDivisor))
-    const indices = Object.fromEntries(entries.map(([k]) => [k, 0]))
-    let entryIdx = 0
-
-    function tick() {
-      const [field, text] = entries[entryIdx]
-      indices[field] = Math.min(indices[field] + charsPerTick, text.length)
-      onAnimate?.(field, text.slice(0, indices[field]))
-      if (indices[field] >= text.length) entryIdx++
-      if (entryIdx >= entries.length) {
-        animating = false
-        notify()
-        onAnimateDone?.()
-      } else {
-        timer = setTimeout(tick, tickMs)
-      }
-    }
-
-    timer = setTimeout(tick, tickMs)
-  }
-
-  return {
-    get loading() { return loading },
-    get animating() { return animating },
-
-    subscribe(fn) {
-      listeners.add(fn)
-      return () => listeners.delete(fn)
-    },
-
-    async complete({ provider, model, key, prompt, maxTokens, agentOptions, onResult, onError, parseResponse, typewriter = DEFAULT_TYPEWRITER, onAnimate, onAnimateDone }) {
-      loading = true
-      notify()
-
-      try {
-        let text
-        if (agentOptions) {
-          const { system, tools, messages, maxTurns, onToolCall } = agentOptions
-          text = await callAnthropicWithTools({ key, model, system, tools, messages, maxTokens, maxTurns, onToolCall })
-        } else {
-          text = await callProvider({ provider, model, key, prompt, maxTokens })
-        }
-
-        const result = parseResponse ? parseResponse(text) : { text }
-        loading = false
-
-        if (typewriter && onAnimate) {
-          animating = true
-          notify()
-          onResult?.(result)
-          runTypewriter(result, { typewriter, onAnimate, onAnimateDone })
-        } else {
-          notify()
-          onResult?.(result)
-          onAnimateDone?.()
-        }
-      } catch (e) {
-        loading = false
-        animating = false
-        notify()
-        onError?.(e instanceof AiApiError ? e : new AiApiError('api_error'))
-      }
-    },
-
-    cancel() {
-      clearTimeout(timer)
-      loading = false
-      animating = false
-      notify()
-    },
-  }
-}
+import { callProvider, callAnthropicWithTools } from './fetch.js'
+import { AiApiError } from './providers.js'
+
+const DEFAULT_TYPEWRITER = { tickMs: 33, minCharsPerTick: 2, charDivisor: 40 }
+
+/**
+ * Vanilla completion runner. No React required.
+ * Returns { complete(options), cancel() } plus a subscribe() for state changes.
+ *
+ * State: { loading: boolean, animating: boolean }
+ *
+ * options for complete():
+ *   provider, model, key, prompt, maxTokens: for standard completions
+ *   agentOptions: { system, tools, messages, maxTurns, onToolCall }: for agentic
+ *   onResult(fields)       : called with parsed result after completion
+ *   onError(error)         : called with AiApiError on failure
+ *   parseResponse(text)    : maps raw text to result fields object
+ *   typewriter             : { tickMs, minCharsPerTick, charDivisor } or false
+ *   onAnimate(field, text) : called each tick with field + current text slice
+ *   onAnimateDone()        : called when typewriter finishes
+ */
+export function createCompletion() {
+  let loading = false
+  let animating = false
+  let timer = null
+  const listeners = new Set()
+  const notify = () => listeners.forEach(fn => fn({ loading, animating }))
+
+  function runTypewriter(fields, { typewriter, onAnimate, onAnimateDone }) {
+    clearTimeout(timer)
+    const { tickMs, minCharsPerTick, charDivisor } = { ...DEFAULT_TYPEWRITER, ...typewriter }
+
+    const entries = Object.entries(fields).filter(([, v]) => typeof v === 'string' && v.length > 0)
+    if (!entries.length) {
+      animating = false
+      notify()
+      onAnimateDone?.()
+      return
+    }
+
+    const total = entries.reduce((sum, [, v]) => sum + v.length, 0)
+    const charsPerTick = Math.max(minCharsPerTick, Math.ceil(total / charDivisor))
+    const indices = Object.fromEntries(entries.map(([k]) => [k, 0]))
+    let entryIdx = 0
+
+    function tick() {
+      const [field, text] = entries[entryIdx]
+      indices[field] = Math.min(indices[field] + charsPerTick, text.length)
+      onAnimate?.(field, text.slice(0, indices[field]))
+      if (indices[field] >= text.length) entryIdx++
+      if (entryIdx >= entries.length) {
+        animating = false
+        notify()
+        onAnimateDone?.()
+      } else {
+        timer = setTimeout(tick, tickMs)
+      }
+    }
+
+    timer = setTimeout(tick, tickMs)
+  }
+
+  return {
+    get loading() { return loading },
+    get animating() { return animating },
+
+    subscribe(fn) {
+      listeners.add(fn)
+      return () => listeners.delete(fn)
+    },
+
+    async complete({ provider, model, key, prompt, maxTokens, agentOptions, onResult, onError, parseResponse, typewriter = DEFAULT_TYPEWRITER, onAnimate, onAnimateDone }) {
+      loading = true
+      notify()
+
+      try {
+        let text
+        if (agentOptions) {
+          const { system, tools, messages, maxTurns, onToolCall } = agentOptions
+          text = await callAnthropicWithTools({ key, model, system, tools, messages, maxTokens, maxTurns, onToolCall })
+        } else {
+          text = await callProvider({ provider, model, key, prompt, maxTokens })
+        }
+
+        const result = parseResponse ? parseResponse(text) : { text }
+        loading = false
+
+        if (typewriter && onAnimate) {
+          animating = true
+          notify()
+          onResult?.(result)
+          runTypewriter(result, { typewriter, onAnimate, onAnimateDone })
+        } else {
+          notify()
+          onResult?.(result)
+          onAnimateDone?.()
+        }
+      } catch (e) {
+        loading = false
+        animating = false
+        notify()
+        onError?.(e instanceof AiApiError ? e : new AiApiError('api_error'))
+      }
+    },
+
+    cancel() {
+      clearTimeout(timer)
+      loading = false
+      animating = false
+      notify()
+    },
+  }
+}

package/createProviderConfig.js

@@ -1,85 +1,85 @@
-import { DEFAULT_MODELS, DEFAULT_PROVIDERS, DEFAULT_PROVIDER_LABELS } from './providers.js'
-
-async function getAdapter() {
-  const mod = await import('@ulam/sawsawan')
-  return mod.getAdapter()
-}
-
-/**
- * Vanilla provider config store. No React required.
- * Returns a plain object with getters, setters, and a subscribe() for change notifications.
- *
- * storageKeys: { provider, modelPrefix, keyPrefix, mode? }
- * providers: optional array of { id, label, defaultModel? }
- */
-export async function createProviderConfig(storageKeys, providers = DEFAULT_PROVIDERS) {
-  const { provider: providerKey, modelPrefix, keyPrefix, mode: modeKey } = storageKeys
-  const adapter = await getAdapter()
-
-  const providerList = providers.map(p =>
-    typeof p === 'string' ? { id: p, label: DEFAULT_PROVIDER_LABELS[p] || p } : p
-  )
-
-  let provider = adapter.readPref(providerKey) || providerList[0]?.id || 'anthropic'
-
-  let models = Object.fromEntries(
-    providerList.map(p => [
-      p.id,
-      adapter.readPref(`${modelPrefix}${p.id}`) || p.defaultModel || DEFAULT_MODELS[p.id] || '',
-    ])
-  )
-
-  let mode = modeKey ? adapter.readPref(modeKey) === 'true' : false
-
-  const listeners = new Set()
-  const notify = () => listeners.forEach(fn => fn())
-
-  return {
-    get provider() { return provider },
-    get models() { return { ...models } },
-    get mode() { return mode },
-    get providers() { return providerList },
-
-    setProvider(id) {
-      adapter.writePref(providerKey, id)
-      provider = id
-      notify()
-    },
-
-    setModel(providerId, modelId) {
-      adapter.writePref(`${modelPrefix}${providerId}`, modelId)
-      models = { ...models, [providerId]: modelId }
-      notify()
-    },
-
-    setMode(value) {
-      if (!modeKey) return
-      adapter.writePref(modeKey, value ? 'true' : 'false')
-      mode = value
-      notify()
-    },
-
-    async setKey(providerId, value) {
-      await adapter.setKey(`${keyPrefix}${providerId}`, value)
-    },
-
-    async getKey(providerId) {
-      return (await adapter.getKey(`${keyPrefix}${providerId}`)) || ''
-    },
-
-    getModel(providerId) {
-      return models[providerId] || DEFAULT_MODELS[providerId] || ''
-    },
-
-    getLabel(providerId) {
-      return providerList.find(p => p.id === providerId)?.label
-        || DEFAULT_PROVIDER_LABELS[providerId]
-        || providerId
-    },
-
-    subscribe(fn) {
-      listeners.add(fn)
-      return () => listeners.delete(fn)
-    },
-  }
-}
+import { DEFAULT_MODELS, DEFAULT_PROVIDERS, DEFAULT_PROVIDER_LABELS } from './providers.js'
+
+async function getAdapter() {
+  const mod = await import('@ulam/sawsawan')
+  return mod.getAdapter()
+}
+
+/**
+ * Vanilla provider config store. No React required.
+ * Returns a plain object with getters, setters, and a subscribe() for change notifications.
+ *
+ * storageKeys: { provider, modelPrefix, keyPrefix, mode? }
+ * providers: optional array of { id, label, defaultModel? }
+ */
+export async function createProviderConfig(storageKeys, providers = DEFAULT_PROVIDERS) {
+  const { provider: providerKey, modelPrefix, keyPrefix, mode: modeKey } = storageKeys
+  const adapter = await getAdapter()
+
+  const providerList = providers.map(p =>
+    typeof p === 'string' ? { id: p, label: DEFAULT_PROVIDER_LABELS[p] || p } : p
+  )
+
+  let provider = adapter.readPref(providerKey) || providerList[0]?.id || 'anthropic'
+
+  let models = Object.fromEntries(
+    providerList.map(p => [
+      p.id,
+      adapter.readPref(`${modelPrefix}${p.id}`) || p.defaultModel || DEFAULT_MODELS[p.id] || '',
+    ])
+  )
+
+  let mode = modeKey ? adapter.readPref(modeKey) === 'true' : false
+
+  const listeners = new Set()
+  const notify = () => listeners.forEach(fn => fn())
+
+  return {
+    get provider() { return provider },
+    get models() { return { ...models } },
+    get mode() { return mode },
+    get providers() { return providerList },
+
+    setProvider(id) {
+      adapter.writePref(providerKey, id)
+      provider = id
+      notify()
+    },
+
+    setModel(providerId, modelId) {
+      adapter.writePref(`${modelPrefix}${providerId}`, modelId)
+      models = { ...models, [providerId]: modelId }
+      notify()
+    },
+
+    setMode(value) {
+      if (!modeKey) return
+      adapter.writePref(modeKey, value ? 'true' : 'false')
+      mode = value
+      notify()
+    },
+
+    async setKey(providerId, value) {
+      await adapter.setKey(`${keyPrefix}${providerId}`, value)
+    },
+
+    async getKey(providerId) {
+      return (await adapter.getKey(`${keyPrefix}${providerId}`)) || ''
+    },
+
+    getModel(providerId) {
+      return models[providerId] || DEFAULT_MODELS[providerId] || ''
+    },
+
+    getLabel(providerId) {
+      return providerList.find(p => p.id === providerId)?.label
+        || DEFAULT_PROVIDER_LABELS[providerId]
+        || providerId
+    },
+
+    subscribe(fn) {
+      listeners.add(fn)
+      return () => listeners.delete(fn)
+    },
+  }
+}