@ossy/media-tasks 3.18.0 → 3.19.0

package/src/embed-resource.js

@@ -0,0 +1,111 @@
+/**
+ * Embed-resource task (#952).
+ *
+ * Converts a resource's text content into a dense vector via OpenRouter's
+ * embeddings API and stores it for semantic search and clustering.
+ *
+ * Text source resolution (priority order):
+ * 1. Explicit `text` input
+ * 2. Markdown `content.body`
+ * 3. text/* file bytes (via originalObjectKey)
+ * 4. VCD descriptor — `taskArtifacts.visual-content-descriptors.descriptors.body.description`
+ * 5. run-prompt completion — `taskArtifacts.run-prompt.completion.body.text`
+ *
+ * This means image resources get embedded once VCD or run-prompt has run on them.
+ */
+
+import { MARKDOWN_DOCUMENT_TYPE, isTextContentType } from './run-prompt.js'
+
+export { MARKDOWN_DOCUMENT_TYPE, isTextContentType }
+
+export const DEFAULT_EMBED_MODEL = 'openai/text-embedding-3-small'
+export const DEFAULT_EMBED_DIMENSIONS = 1536
+/** Soft character ceiling — text-embedding-3-small supports ~8k tokens (~32k chars). */
+export const MAX_EMBED_CHARS = 32_000
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+export function normalizeEmbedModel (value) {
+  const raw = typeof value === 'string' ? value.trim() : ''
+  return raw || DEFAULT_EMBED_MODEL
+}
+
+/**
+ * @param {string} text
+ * @returns {{ text: string, truncated: boolean }}
+ */
+export function clampEmbedText (text) {
+  const t = typeof text === 'string' ? text.trim() : ''
+  if (t.length <= MAX_EMBED_CHARS) return { text: t, truncated: false }
+  return { text: t.slice(0, MAX_EMBED_CHARS), truncated: true }
+}
+
+/**
+ * Resolve the text to embed from the resource and optional inputs.
+ *
+ * @param {{
+ *   inputText?: unknown,
+ *   resource?: object | null,
+ *   fileText?: string | null,
+ * }} opts
+ * @returns {{ text: string, source: string }}
+ */
+export function resolveEmbedText ({ inputText, resource, fileText } = {}) {
+  const fromInput = typeof inputText === 'string' ? inputText.trim() : ''
+  if (fromInput) return { text: fromInput, source: 'input' }
+
+  if (resource?.type === MARKDOWN_DOCUMENT_TYPE) {
+    const body = resource?.content?.body
+    if (typeof body === 'string' && body.trim()) {
+      return { text: body.trim(), source: 'markdown-body' }
+    }
+  }
+
+  if (typeof fileText === 'string' && fileText.trim()) {
+    return { text: fileText.trim(), source: 'file-bytes' }
+  }
+
+  // VCD: description from visual-content-descriptors artifact
+  const vcdDescription = resource?.content?.taskArtifacts?.['visual-content-descriptors']?.descriptors?.body?.description
+  if (typeof vcdDescription === 'string' && vcdDescription.trim()) {
+    return { text: vcdDescription.trim(), source: 'vcd-description' }
+  }
+
+  // run-prompt completion text
+  const promptText = resource?.content?.taskArtifacts?.['run-prompt']?.completion?.body?.text
+  if (typeof promptText === 'string' && promptText.trim()) {
+    return { text: promptText.trim(), source: 'run-prompt-completion' }
+  }
+
+  return { text: '', source: 'none' }
+}
+
+/**
+ * Call OpenRouter embeddings and return the float vector.
+ *
+ * @param {{ embeddings: { create: Function } }} client   OpenAI-compatible client
+ * @param {{ text: string, model?: string }} opts
+ * @returns {Promise<{ vector: number[], dimensions: number, inputTokens: number }>}
+ */
+export async function createEmbedding (client, { text, model }) {
+  if (!text || !String(text).trim()) throw new Error('[embed-resource] text is required')
+  const resolvedModel = normalizeEmbedModel(model)
+
+  const response = await client.embeddings.create({
+    model: resolvedModel,
+    input: text,
+  })
+
+  const vector = response.data?.[0]?.embedding
+  if (!Array.isArray(vector) || !vector.length) {
+    throw new Error('[embed-resource] empty embedding returned')
+  }
+
+  return {
+    vector,
+    dimensions: vector.length,
+    inputTokens: response.usage?.prompt_tokens ?? 0,
+  }
+}

package/src/embed-resource.schema.js

@@ -0,0 +1,46 @@
+import { TASK_OUTPUT_PROVENANCE_FIELDS } from '@ossy/schema'
+
+export default {
+  name: 'Embed resource',
+  id: '@ossy/media-tasks/schema/embed-resource',
+  categoryName: 'Media processing',
+  icon: 'cpu',
+  fields: [
+    {
+      name: 'model',
+      type: 'text',
+      description: 'Embedding model slug (e.g. openai/text-embedding-3-small)',
+    },
+    {
+      name: 'dimensions',
+      type: 'number',
+      description: 'Vector dimensionality',
+    },
+    {
+      name: 'textSource',
+      type: 'text',
+      description: 'Where the embedded text came from: input | markdown-body | file-bytes | vcd-description | run-prompt-completion',
+    },
+    {
+      name: 'textLength',
+      type: 'number',
+      description: 'Character count of the embedded text (after clamping)',
+    },
+    {
+      name: 'truncated',
+      type: 'boolean',
+      description: 'True when the text was truncated to the embedding character ceiling',
+    },
+    {
+      name: 'inputTokens',
+      type: 'number',
+      description: 'Tokens consumed by the embedding call',
+    },
+    {
+      name: 'vectorKey',
+      type: 'text',
+      description: 'Storage key for the raw embedding JSON artifact',
+    },
+    ...TASK_OUTPUT_PROVENANCE_FIELDS,
+  ],
+}

package/src/embed-resource.spec.js

@@ -0,0 +1,179 @@
+import {
+  DEFAULT_EMBED_MODEL,
+  DEFAULT_EMBED_DIMENSIONS,
+  MAX_EMBED_CHARS,
+  clampEmbedText,
+  normalizeEmbedModel,
+  resolveEmbedText,
+  createEmbedding,
+} from './embed-resource.js'
+import { MARKDOWN_DOCUMENT_TYPE } from './run-prompt.js'
+
+describe('embed-resource helpers', () => {
+  describe('normalizeEmbedModel', () => {
+    it('returns the model unchanged when valid', () => {
+      expect(normalizeEmbedModel('openai/text-embedding-3-small')).toBe('openai/text-embedding-3-small')
+      expect(normalizeEmbedModel('openai/text-embedding-3-large')).toBe('openai/text-embedding-3-large')
+    })
+    it('falls back to default for blank input', () => {
+      expect(normalizeEmbedModel('')).toBe(DEFAULT_EMBED_MODEL)
+      expect(normalizeEmbedModel('   ')).toBe(DEFAULT_EMBED_MODEL)
+      expect(normalizeEmbedModel(undefined)).toBe(DEFAULT_EMBED_MODEL)
+      expect(normalizeEmbedModel(null)).toBe(DEFAULT_EMBED_MODEL)
+    })
+  })
+
+  describe('clampEmbedText', () => {
+    it('does not truncate short text', () => {
+      expect(clampEmbedText('hello world')).toEqual({ text: 'hello world', truncated: false })
+    })
+    it('trims surrounding whitespace', () => {
+      expect(clampEmbedText('  hi  ')).toEqual({ text: 'hi', truncated: false })
+    })
+    it('truncates to MAX_EMBED_CHARS', () => {
+      const long = 'x'.repeat(MAX_EMBED_CHARS + 100)
+      const result = clampEmbedText(long)
+      expect(result.truncated).toBe(true)
+      expect(result.text).toHaveLength(MAX_EMBED_CHARS)
+    })
+    it('handles non-string gracefully', () => {
+      expect(clampEmbedText(undefined)).toEqual({ text: '', truncated: false })
+      expect(clampEmbedText(null)).toEqual({ text: '', truncated: false })
+    })
+  })
+
+  describe('resolveEmbedText', () => {
+    it('prefers explicit text input', () => {
+      const resource = {
+        type: MARKDOWN_DOCUMENT_TYPE,
+        content: { body: 'md body' },
+      }
+      expect(resolveEmbedText({ inputText: ' from input ', resource })).toEqual({
+        text: 'from input',
+        source: 'input',
+      })
+    })
+
+    it('uses markdown body for markdown documents', () => {
+      const resource = {
+        type: MARKDOWN_DOCUMENT_TYPE,
+        content: { body: '  # Hello  ' },
+      }
+      expect(resolveEmbedText({ resource })).toEqual({
+        text: '# Hello',
+        source: 'markdown-body',
+      })
+    })
+
+    it('uses file text when resource is not markdown', () => {
+      const resource = { type: '@ossy/platform/schema/file', content: { ContentType: 'text/plain' } }
+      expect(resolveEmbedText({ resource, fileText: '  file bytes  ' })).toEqual({
+        text: 'file bytes',
+        source: 'file-bytes',
+      })
+    })
+
+    it('falls back to VCD description', () => {
+      const resource = {
+        type: '@ossy/platform/schema/file',
+        content: {
+          ContentType: 'image/jpeg',
+          taskArtifacts: {
+            'visual-content-descriptors': {
+              descriptors: { body: { description: 'A sunny beach' } },
+            },
+          },
+        },
+      }
+      expect(resolveEmbedText({ resource })).toEqual({
+        text: 'A sunny beach',
+        source: 'vcd-description',
+      })
+    })
+
+    it('falls back to run-prompt completion', () => {
+      const resource = {
+        type: '@ossy/platform/schema/file',
+        content: {
+          ContentType: 'image/png',
+          taskArtifacts: {
+            'run-prompt': {
+              completion: { body: { text: 'AI summary of content' } },
+            },
+          },
+        },
+      }
+      expect(resolveEmbedText({ resource })).toEqual({
+        text: 'AI summary of content',
+        source: 'run-prompt-completion',
+      })
+    })
+
+    it('returns source=none when nothing is found', () => {
+      expect(resolveEmbedText({})).toEqual({ text: '', source: 'none' })
+      expect(resolveEmbedText({ resource: {} })).toEqual({ text: '', source: 'none' })
+    })
+  })
+})
+
+describe('createEmbedding', () => {
+  const FAKE_VECTOR = Array.from({ length: DEFAULT_EMBED_DIMENSIONS }, (_, i) => i / DEFAULT_EMBED_DIMENSIONS)
+
+  it('calls embeddings.create with the right params and returns vector + metadata', async () => {
+    const calls = []
+    const client = {
+      embeddings: {
+        create: async (args) => {
+          calls.push(args)
+          return {
+            data: [{ embedding: FAKE_VECTOR }],
+            usage: { prompt_tokens: 42 },
+          }
+        },
+      },
+    }
+    const result = await createEmbedding(client, {
+      text: 'semantic knowledge base',
+      model: 'openai/text-embedding-3-small',
+    })
+    expect(calls[0]).toEqual({
+      model: 'openai/text-embedding-3-small',
+      input: 'semantic knowledge base',
+    })
+    expect(result.vector).toBe(FAKE_VECTOR)
+    expect(result.dimensions).toBe(DEFAULT_EMBED_DIMENSIONS)
+    expect(result.inputTokens).toBe(42)
+  })
+
+  it('uses the default model when none is provided', async () => {
+    const calls = []
+    const client = {
+      embeddings: {
+        create: async (args) => {
+          calls.push(args)
+          return {
+            data: [{ embedding: [0.1, 0.2, 0.3] }],
+            usage: { prompt_tokens: 3 },
+          }
+        },
+      },
+    }
+    await createEmbedding(client, { text: 'test' })
+    expect(calls[0].model).toBe(DEFAULT_EMBED_MODEL)
+  })
+
+  it('throws on empty text', async () => {
+    const client = { embeddings: { create: async () => ({}) } }
+    await expect(createEmbedding(client, { text: '' })).rejects.toThrow(/text is required/)
+    await expect(createEmbedding(client, { text: '  ' })).rejects.toThrow(/text is required/)
+  })
+
+  it('throws when the API returns an empty embedding', async () => {
+    const client = {
+      embeddings: {
+        create: async () => ({ data: [{ embedding: [] }], usage: { prompt_tokens: 1 } }),
+      },
+    }
+    await expect(createEmbedding(client, { text: 'test' })).rejects.toThrow(/empty embedding/)
+  })
+})

package/src/embed-resource.task.js

@@ -0,0 +1,199 @@
+import { createLogger } from '@ossy/observability'
+import { StorageClient } from '@ossy/platform'
+import { originalObjectKey, taskArtifactObjectKey } from '@ossy/platform/storage-keys'
+import { GetResource, placeTaskArtifacts } from '@ossy/resources'
+import { upsertEmbedding } from '@ossy/platform/vector/vector-store'
+import { loadSourceBuffer } from './load-source-buffer.js'
+import { resolveConfiguredPlacements } from './resolve-configured-placement.js'
+import {
+  MARKDOWN_DOCUMENT_TYPE,
+  isTextContentType,
+  markdownDocumentBody,
+} from './run-prompt.js'
+import {
+  DEFAULT_EMBED_MODEL,
+  MAX_EMBED_CHARS,
+  clampEmbedText,
+  createEmbedding,
+  normalizeEmbedModel,
+  resolveEmbedText,
+} from './embed-resource.js'
+
+const log = createLogger('media-tasks')
+
+const TASK_ID = '@ossy/media-tasks/tasks/embed-resource'
+const SCHEMA_ID = '@ossy/media-tasks/schema/embed-resource'
+const CONCEPT = 'embed-resource'
+const VECTOR_ARTIFACT = 'vector'
+const OUTPUT = {
+  name: 'embedding',
+  kind: 'location',
+  schemaId: SCHEMA_ID,
+  contentType: 'application/json',
+}
+
+export const metadata = {
+  id: TASK_ID,
+  triggers: [
+    {
+      kind: 'on_action',
+      action: '@ossy/media-tasks/actions/embed-resource',
+    },
+    {
+      type: MARKDOWN_DOCUMENT_TYPE,
+      event: 'Created',
+    },
+    {
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      match: { 'content.ContentType': 'text/*' },
+    },
+  ],
+  outputs: [OUTPUT],
+  inputs: [
+    {
+      name: 'text',
+      type: 'text',
+      multiline: true,
+      sources: ['payload', 'config'],
+      description: 'Text to embed. When empty, uses the Markdown body, text file, VCD description, or run-prompt completion.',
+    },
+    {
+      name: 'model',
+      type: 'text',
+      default: DEFAULT_EMBED_MODEL,
+      sources: ['payload', 'config'],
+      description: `OpenRouter embedding model slug (default ${DEFAULT_EMBED_MODEL})`,
+    },
+  ],
+  configurable: true,
+}
+
+export async function run ({ event, payload, sdk, integrations, inputs }) {
+  const openrouter = integrations?.get?.('openrouter')
+  if (!openrouter) {
+    log.warn('[media-tasks/tasks/embed-resource] openrouter integration not connected')
+    throw Object.assign(new Error('OpenRouter integration not available'), { status: 503 })
+  }
+
+  const resourceId = event?.resourceId || payload?.resourceId || null
+  log.info(`[media-tasks/tasks/embed-resource] starting${resourceId ? ` for resource ${resourceId}` : ''}`)
+
+  let resource = null
+  let fileText = null
+  if (resourceId) {
+    resource = await sdk.invoke(GetResource, { resourceId })
+    fileText = await loadFileText(resource)
+  }
+
+  const { text: rawText, source: textSource } = resolveEmbedText({
+    inputText: inputs?.text,
+    resource,
+    fileText,
+  })
+
+  if (!rawText) {
+    throw Object.assign(
+      new Error('[media-tasks/tasks/embed-resource] no text found to embed (provide text input, or ensure resource has Markdown body, text content, VCD, or run-prompt output)'),
+      { status: 400 },
+    )
+  }
+
+  const { text, truncated } = clampEmbedText(rawText)
+  const model = normalizeEmbedModel(inputs?.model)
+
+  const { vector, dimensions, inputTokens } = await createEmbedding(openrouter, { text, model })
+  log.info(`[media-tasks/tasks/embed-resource] embedded ${text.length} chars → ${dimensions}d vector (${inputTokens} tokens, source: ${textSource})`)
+
+  // Always store in MongoDB vector store when we have a resource.
+  if (resource?.id) {
+    await upsertEmbedding({
+      resourceId: resource.id,
+      workspaceId: resource.belongsTo,
+      model,
+      dimensions,
+      vector,
+      textSource,
+      textLength: text.length,
+    })
+    log.info(`[media-tasks/tasks/embed-resource] upserted vector for resource ${resource.id}`)
+  }
+
+  if (!resource?.id) {
+    return {
+      output: OUTPUT.name,
+      model,
+      dimensions,
+      textSource,
+      textLength: text.length,
+      truncated,
+      inputTokens,
+      placedResourceIds: [],
+    }
+  }
+
+  const body = {
+    model,
+    dimensions,
+    textSource,
+    textLength: text.length,
+    truncated,
+    inputTokens,
+    vectorKey: taskArtifactObjectKey(resource.id, CONCEPT, VECTOR_ARTIFACT),
+  }
+
+  // Persist the raw vector as a JSON artifact for potential offline analysis.
+  const vectorKey = body.vectorKey
+  await StorageClient.save(vectorKey, Buffer.from(JSON.stringify({ vector }), 'utf8'))
+  log.info(`[media-tasks/tasks/embed-resource] saved vector artifact ${vectorKey}`)
+
+  const metaKey = taskArtifactObjectKey(resource.id, CONCEPT, OUTPUT.name)
+  await StorageClient.save(metaKey, Buffer.from(JSON.stringify(body), 'utf8'))
+  log.info(`[media-tasks/tasks/embed-resource] saved ${metaKey}`)
+
+  const placementLocations = await resolveConfiguredPlacements(sdk, TASK_ID, OUTPUT.name)
+  const placed = await placeTaskArtifacts({
+    sdk,
+    sourceResource: resource,
+    taskId: TASK_ID,
+    output: OUTPUT,
+    body,
+    artifactKey: metaKey,
+    placementLocations,
+  })
+  if (placed.length) {
+    log.info(`[media-tasks/tasks/embed-resource] placed ${placed.length} resource(s)`)
+  } else {
+    log.info('[media-tasks/tasks/embed-resource] artifact only (no placement location configured)')
+  }
+
+  return {
+    output: OUTPUT.name,
+    key: metaKey,
+    vectorKey,
+    model,
+    dimensions,
+    textSource,
+    textLength: text.length,
+    truncated,
+    inputTokens,
+    placedResourceIds: placed.map((r) => r.id),
+    placedResourceId: placed[0]?.id ?? null,
+  }
+}
+
+/**
+ * @param {object | null | undefined} resource
+ * @returns {Promise<string | null>}
+ */
+async function loadFileText (resource) {
+  if (!resource) return null
+  if (resource.type === MARKDOWN_DOCUMENT_TYPE) {
+    return markdownDocumentBody(resource) || null
+  }
+  const contentType = resource?.content?.ContentType || ''
+  if (!isTextContentType(contentType)) return null
+  const key = originalObjectKey(resource.id)
+  const buffer = await loadSourceBuffer(key)
+  return buffer ? buffer.toString('utf8') : null
+}

package/src/en.translations.json

@@ -0,0 +1,4 @@
+{
+  "@ossy/media-tasks/actions/convert-common-audio.label": "Convert audio format",
+  "@ossy/media-tasks/actions/convert-common-audio.description": "Convert audio between MP3, AAC, OGG, WAV, AIFF, and FLAC."
+}

package/src/extract-colors.action.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/media-tasks/actions/extract-colors',
+  access: 'workspace',
+  label: 'automation.task.extract-colors.title',
+}

package/src/extract-colors.task.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@ossy/observability'
 import { StorageClient } from '@ossy/platform'
-import { taskArtifactObjectKey } from '@ossy/platform/storage-keys'
+import { originalObjectKey, taskArtifactObjectKey } from '@ossy/platform/storage-keys'
 import { GetResource, placeTaskArtifacts } from '@ossy/resources'
 import { extractColorsFromBuffer } from './extract-colors.js'
 import { loadSourceBuffer } from './load-source-buffer.js'
@@ -27,22 +27,28 @@ export const metadata = {
       event: 'Created',
       match: { 'content.ContentType': 'image/*' },
     },
+    {
+      kind: 'on_action',
+      action: '@ossy/media-tasks/actions/extract-colors',
+    },
   ],
   outputs: [OUTPUT],
   configurable: true,
 }
 
-export async function run ({ event, sdk }) {
+export async function run ({ event, payload, sdk }) {
   const { default: sharp } = await import('sharp')
-  const resourceId = event.resourceId
+  const resourceId = event?.resourceId || payload?.resourceId
+  if (!resourceId) {
+    throw new Error('[media-tasks/tasks/extract-colors] resourceId is required')
+  }
 
   log.info(`[media-tasks/tasks/extract-colors] starting for resource ${resourceId}`)
 
   const resource = await sdk.invoke(GetResource, { resourceId })
-  const key = resource?.content?.Key
-  if (!key) {
-    throw new Error(`[media-tasks/tasks/extract-colors] missing storage key for ${resourceId}`)
-  }
+  // content.Key is stripped by the API media layer (replaced with src URL);
+  // derive the storage key deterministically from the resource ID instead.
+  const key = originalObjectKey(resource.id)
 
   const sourceBuffer = await loadSourceBuffer(key)
   if (!sourceBuffer) {

package/src/openrouter.integration.js

@@ -10,7 +10,8 @@ const DEFAULT_APP_TITLE = 'Ossy'
 
 /**
  * Returns an OpenAI-compatible client pointed at OpenRouter.
- * Tasks receive this via `integrations.get('openrouter')`.
+ * Tasks receive this via `integrations.get('openrouter')` for chat completions
+ * and TTS (`audio.speech`).
  *
  * @param {{ env: NodeJS.ProcessEnv }} opts
  * @returns {import('openai').OpenAI}

package/src/resize-common-web.action.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/media-tasks/actions/resize-common-web',
+  access: 'workspace',
+  label: 'automation.task.resize-common-web.title',
+}

package/src/resize-common-web.task.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@ossy/observability'
 import { StorageClient } from '@ossy/platform'
-import { taskArtifactObjectKey } from '@ossy/platform/storage-keys'
+import { originalObjectKey, taskArtifactObjectKey } from '@ossy/platform/storage-keys'
 import { GetResource, placeTaskArtifacts } from '@ossy/resources'
 import { encodeBlurhashFromBuffer } from './encode-blurhash.js'
 import { loadSourceBuffer } from './load-source-buffer.js'
@@ -35,22 +35,28 @@ export const metadata = {
       event: 'Created',
       match: { 'content.ContentType': 'image/*' },
     },
+    {
+      kind: 'on_action',
+      action: '@ossy/media-tasks/actions/resize-common-web',
+    },
   ],
   outputs: [OUTPUT],
   configurable: true,
 }
 
-export async function run ({ event, sdk }) {
+export async function run ({ event, payload, sdk }) {
   const { default: sharp } = await import('sharp')
-  const resourceId = event.resourceId
+  const resourceId = event?.resourceId || payload?.resourceId
+  if (!resourceId) {
+    throw new Error('[media-tasks/tasks/resize-common-web] resourceId is required')
+  }
 
   log.info(`[media-tasks/tasks/resize-common-web] starting for resource ${resourceId}`)
 
   const resource = await sdk.invoke(GetResource, { resourceId })
-  const key = resource?.content?.Key
-  if (!key) {
-    throw new Error(`[media-tasks/tasks/resize-common-web] missing storage key for ${resourceId}`)
-  }
+  // content.Key is stripped by the API media layer (replaced with src URL);
+  // derive the storage key deterministically from the resource ID instead.
+  const key = originalObjectKey(resource.id)
 
   const sourceBuffer = await loadSourceBuffer(key)
   if (!sourceBuffer) {

package/src/run-prompt.task.js

@@ -53,6 +53,12 @@ export const metadata = {
       type: MARKDOWN_DOCUMENT_TYPE,
       event: 'Created',
     },
+    // Ceiling for workspace on_action authoring / ADR 0003 primary-action parity.
+    // Storage → Tasks still omits this task until a prompt UI exists (required input).
+    {
+      kind: 'on_action',
+      action: '@ossy/media-tasks/actions/run-prompt',
+    },
   ],
   outputs: [OUTPUT],
   inputs: [

package/src/sv.translations.json

@@ -0,0 +1,4 @@
+{
+  "@ossy/media-tasks/actions/convert-common-audio.label": "Konvertera ljudformat",
+  "@ossy/media-tasks/actions/convert-common-audio.description": "Konvertera ljud mellan MP3, AAC, OGG, WAV, AIFF och FLAC."
+}

package/src/text-to-voice.action.js

@@ -0,0 +1,5 @@
+export const metadata = {
+  id: '@ossy/media-tasks/actions/text-to-voice',
+  access: 'workspace',
+  label: 'automation.task.text-to-voice.title',
+}